diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 039a19f26a..bad49f2c9b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -21,29 +21,39 @@ jobs: - name: 'Windows static - C++' os: windows-latest python_bindings: OFF - additional_cmake_options: -DLibXml2_DIR="C:\libxml2\libxml2-2.9.10\CMake" -DZLIB_DIR="C:\zlib\lib\cmake\ZLIB-1.2.12" + additional_cmake_options: -DLibXml2_DIR=C:\libxml2\libxml2-2.9.10\CMake -DZLIB_DIR=C:\zlib\lib\cmake\ZLIB-1.2.12 -DSymEngine_DIR=C:\symengine\debug\CMake - name: 'Windows shared - C++/Python' os: windows-latest python_bindings: ON - additional_cmake_options: -DLibXml2_DIR="C:\libxml2\libxml2-2.9.10\CMake" -DZLIB_DIR="C:\zlib\lib\cmake\ZLIB-1.2.12" + additional_cmake_options: -DLibXml2_DIR=C:\libxml2\libxml2-2.9.10\CMake -DZLIB_DIR=C:\zlib\lib\cmake\ZLIB-1.2.12 -DSymEngine_DIR=C:\symengine\debug\CMake - name: 'Linux static - C++' os: ubuntu-latest python_bindings: OFF + additional_cmake_options: -DCMAKE_PREFIX_PATH=$HOME - name: 'Linux shared - C++/Python' os: ubuntu-latest python_bindings: ON + additional_cmake_options: -DCMAKE_PREFIX_PATH=$HOME - name: 'macOS static - C++ (Intel)' os: macos-15-intel python_bindings: OFF + architecture: Intel + additional_cmake_options: -DCMAKE_PREFIX_PATH=$HOME - name: 'macOS shared - C++/Python (Intel)' os: macos-15-intel python_bindings: ON + architecture: Intel + additional_cmake_options: -DCMAKE_PREFIX_PATH=$HOME - name: 'macOS static - C++ (ARM)' os: macos-latest python_bindings: OFF + architecture: ARM + additional_cmake_options: -DCMAKE_PREFIX_PATH=$HOME - name: 'macOS shared - C++/Python (ARM)' os: macos-latest python_bindings: ON + architecture: ARM + additional_cmake_options: -DCMAKE_PREFIX_PATH=$HOME steps: - name: Check out libCellML uses: actions/checkout@v6 @@ -61,18 +71,30 @@ jobs: uses: TheMrMilchmann/setup-msvc-dev@v4 with: arch: x64 - - name: Install libxml2 (Windows only) + - name: Install dependencies (Windows only) if: ${{ runner.os == 'Windows' }} run: | cd C:\ - curl -L https://github.com/cellml/gha/releases/download/gha/libxml2-Windows.tar.gz -o libxml2.tar.gz -s + curl -L https://github.com/cellml/gha/releases/download/gha/libxml2-Windows-Intel.tar.gz -o libxml2.tar.gz -s tar -xzf libxml2.tar.gz - - name: Install zlib (Windows only) - if: ${{ runner.os == 'Windows' }} - run: | - cd C:\ - curl -L https://github.com/cellml/gha/releases/download/gha/zlib-Windows.tar.gz -o zlib.tar.gz -s + curl -L https://github.com/cellml/gha/releases/download/gha/symengine-Windows-Intel.tar.gz -o symengine.tar.gz -s + tar -xzf symengine.tar.gz + curl -L https://github.com/cellml/gha/releases/download/gha/zlib-Windows-Intel.tar.gz -o zlib.tar.gz -s tar -xzf zlib.tar.gz + - name: Install dependencies (Linux only) + if: ${{ runner.os == 'Linux' }} + run: | + cd $HOME + wget https://github.com/cellml/gha/releases/download/gha/libxml2-Linux-Intel.tar.gz -O - | tar -xz + wget https://github.com/cellml/gha/releases/download/gha/symengine-Linux-Intel.tar.gz -O - | tar -xz + wget https://github.com/cellml/gha/releases/download/gha/zlib-Linux-Intel.tar.gz -O - | tar -xz + - name: Install dependencies (macOS only) + if: ${{ runner.os == 'macOS' }} + run: | + cd $HOME + wget https://github.com/cellml/gha/releases/download/gha/libxml2-macOS-${{ matrix.architecture }}.tar.gz -O - | tar -xz + wget https://github.com/cellml/gha/releases/download/gha/symengine-macOS-${{ matrix.architecture }}.tar.gz -O - | tar -xz + wget https://github.com/cellml/gha/releases/download/gha/zlib-macOS-${{ matrix.architecture }}.tar.gz -O - | tar -xz - name: Install SWIG (macOS only and if needed) if: ${{ runner.os == 'macOS' && matrix.python_bindings == 'ON' }} run: brew install swig @@ -96,21 +118,21 @@ jobs: uses: lukka/get-cmake@latest - name: Install Emscripten run: brew install --overwrite emscripten - - name: Install libxml2 + - name: Install dependencies run: | cd $HOME + wget https://github.com/cellml/gha/releases/download/gha/flint-WASM.tar.gz -O - | tar -xz + wget https://github.com/cellml/gha/releases/download/gha/gmp-WASM.tar.gz -O - | tar -xz wget https://github.com/cellml/gha/releases/download/gha/libxml2-WASM.tar.gz -O - | tar -xz - - name: Install zlib - run: | - cd $HOME + wget https://github.com/cellml/gha/releases/download/gha/mpfr-WASM.tar.gz -O - | tar -xz + wget https://github.com/cellml/gha/releases/download/gha/symengine-WASM.tar.gz -O - | tar -xz wget https://github.com/cellml/gha/releases/download/gha/zlib-WASM.tar.gz -O - | tar -xz - name: Configure libCellML - run: | - emcmake cmake -G Ninja -S . -B build-wasm -DBUILD_TYPE=Release -DLIBXML2_INCLUDE_DIR=$HOME/libxml2/include/libxml2 -DLIBXML2_LIBRARY=$HOME/libxml2/lib/libxml2.a -DZLIB_INCLUDE_DIR=$HOME/zlib/include -DZLIB_LIBRARY=$HOME/zlib/lib/libz.a + run: emcmake cmake -G Ninja -S . -B build -DBUILD_TYPE=Release -DLIBXML2_LIBRARY=$HOME/libxml2/lib/libxml2.a -DLIBXML2_INCLUDE_DIR=$HOME/libxml2/include/libxml2 -DSymEngine_DIR=$HOME/symengine/lib/cmake/symengine -DSYMENGINE_FLINT_LIBRARIES=$HOME/flint/lib/libflint.a -DSYMENGINE_GMP_LIBRARIES=$HOME/gmp/lib/libgmp.a -DSYMENGINE_MPFR_LIBRARIES=$HOME/mpfr/lib/libmpfr.a -DZLIB_LIBRARY=$HOME/zlib/lib/libz.a -DZLIB_INCLUDE_DIR=$HOME/zlib/include - name: Build libCellML - run: cmake --build build-wasm + run: cmake --build build - name: Unit testing - run: cmake --build build-wasm --target jest_test + run: cmake --build build --target jest_test code_formatting: name: Code formatting runs-on: ubuntu-latest @@ -127,15 +149,16 @@ jobs: sudo apt install clang-format - name: Install CMake and Ninja uses: lukka/get-cmake@latest - - name: Configure libCellML + - name: Install dependencies run: | - mkdir build - cd build - cmake -G Ninja .. + cd $HOME + wget https://github.com/cellml/gha/releases/download/gha/libxml2-Linux.tar.gz -O - | tar -xz + wget https://github.com/cellml/gha/releases/download/gha/symengine-Linux.tar.gz -O - | tar -xz + wget https://github.com/cellml/gha/releases/download/gha/zlib-Linux.tar.gz -O - | tar -xz + - name: Configure libCellML + run: cmake -G Ninja -S . -B build -DCMAKE_PREFIX_PATH=$HOME - name: Code formatting - run: | - cd build - ninja test_clang_format + run: cmake --build build --target test_clang_format coverage: name: Code coverage runs-on: macos-latest @@ -152,16 +175,18 @@ jobs: run: | brew install --overwrite llvm echo 'export PATH="/opt/homebrew/opt/llvm/bin:$PATH"' >> ~/.bash_profile - - name: Configure libCellML + - name: Install dependencies run: | - mkdir build - cd build - cmake -G Ninja -DBINDINGS_PYTHON=OFF .. + cd $HOME + wget https://github.com/cellml/gha/releases/download/gha/libxml2-macOS-ARM.tar.gz -O - | tar -xz + wget https://github.com/cellml/gha/releases/download/gha/symengine-macOS-ARM.tar.gz -O - | tar -xz + wget https://github.com/cellml/gha/releases/download/gha/zlib-macOS-ARM.tar.gz -O - | tar -xz + - name: Configure libCellML + run: cmake -G Ninja -S . -B build -DBINDINGS_PYTHON=OFF -DCMAKE_PREFIX_PATH=$HOME - name: Code coverage run: | - cd build - ninja llvm_coverage - if [ `ninja llvm_coverage | grep TOTAL | sed 's/ /\n/g' | grep "100.00%" | wc -l | sed 's/ //g'` -eq 4 ]; then exit 0; else exit 1; fi + cmake --build build --target llvm_coverage + if [ `cmake --build build --target llvm_coverage | grep TOTAL | sed 's/ /\n/g' | grep "100.00%" | wc -l | sed 's/ //g'` -eq 4 ]; then exit 0; else exit 1; fi memory_leaks: name: Memory leaks runs-on: ubuntu-latest @@ -178,15 +203,16 @@ jobs: run: | sudo apt update sudo apt install valgrind - - name: Configure libCellML + - name: Install dependencies run: | - mkdir build - cd build - cmake -G Ninja -DBINDINGS_PYTHON=OFF .. + cd $HOME + wget https://github.com/cellml/gha/releases/download/gha/libxml2-Linux.tar.gz -O - | tar -xz + wget https://github.com/cellml/gha/releases/download/gha/symengine-Linux.tar.gz -O - | tar -xz + wget https://github.com/cellml/gha/releases/download/gha/zlib-Linux.tar.gz -O - | tar -xz + - name: Configure libCellML + run: cmake -G Ninja -S . -B build -DBINDINGS_PYTHON=OFF -DCMAKE_PREFIX_PATH=$HOME - name: Memory leaks - run: | - cd build - ninja memcheck + run: cmake --build build --target memcheck documentation: name: Documentation runs-on: ubuntu-latest @@ -206,12 +232,13 @@ jobs: - name: Install Sphinx run: | pip3 install sphinx - - name: Configure libCellML + - name: Install dependencies run: | - mkdir build - cd build - cmake -G Ninja -DBINDINGS_PYTHON=OFF .. + cd $HOME + wget https://github.com/cellml/gha/releases/download/gha/libxml2-Linux.tar.gz -O - | tar -xz + wget https://github.com/cellml/gha/releases/download/gha/symengine-Linux.tar.gz -O - | tar -xz + wget https://github.com/cellml/gha/releases/download/gha/zlib-Linux.tar.gz -O - | tar -xz + - name: Configure libCellML + run: cmake -G Ninja -S . -B build -DBINDINGS_PYTHON=OFF -DCMAKE_PREFIX_PATH=$HOME - name: Documentation - run: | - cd build - ninja docs + run: cmake --build build --target docs diff --git a/cmake/common.cmake b/cmake/common.cmake index ab5207d8f5..49899cbb1a 100644 --- a/cmake/common.cmake +++ b/cmake/common.cmake @@ -312,6 +312,19 @@ function(redhat_based _RESULT) set(${_RESULT} ${_REDHAT_BASED} PARENT_SCOPE) endfunction() +function(apply_dependency_settings _TARGET) + if(HAVE_ZLIB_TARGET) + target_link_libraries(${_TARGET} PUBLIC zlib) + else() + target_link_libraries(${_TARGET} PUBLIC ${ZLIB_LIBRARIES}) + target_include_directories(${_TARGET} PUBLIC ${ZLIB_INCLUDE_DIRS}) + endif() + + target_include_directories(${_TARGET} SYSTEM PUBLIC ${SYMENGINE_INCLUDE_DIRS} + PRIVATE $) + target_link_libraries(${_TARGET} PUBLIC ${LIBXML2_TARGET} ${SYMENGINE_LIBRARIES} ${ZLIB_TARGET}) +endfunction() + function(get_runtime_dlls_from_target target target_property out_var) set(_result "") get_target_property(_items ${target} INTERFACE_LINK_LIBRARIES) diff --git a/cmake/environmentchecks.cmake b/cmake/environmentchecks.cmake index 21ba618b5a..a543638444 100644 --- a/cmake/environmentchecks.cmake +++ b/cmake/environmentchecks.cmake @@ -114,6 +114,20 @@ resolve_zlib(${LIBXML2_TARGET} ZLIB_TARGET) get_target_property(ZLIB_TARGET_TYPE ${ZLIB_TARGET} TYPE) get_target_property(LIBXML2_TARGET_TYPE ${LIBXML2_TARGET} TYPE) +# Set the minimum policy version to work around SymEngine's outdated CMake requirements. +if(NOT DEFINED CMAKE_POLICY_VERSION_MINIMUM OR CMAKE_POLICY_VERSION_MINIMUM VERSION_LESS "3.10") + set(CMAKE_POLICY_VERSION_MINIMUM 3.10) +endif() + +# Find SymEngine. +find_package(SymEngine REQUIRED CONFIG) +if(TARGET symengine) + set(HAVE_SYMENGINE_TARGET TRUE) + set(SYMENGINE_TARGET symengine) + get_target_property(SYMENGINE_TARGET_TYPE symengine TYPE) + message(STATUS "Found SymEngine: ${SYMENGINE_LIBRARIES} (found version \"${SymEngine_VERSION}\").") +endif() + if(BUILDCACHE_EXE OR CLCACHE_EXE OR CCACHE_EXE) set(COMPILER_CACHE_AVAILABLE TRUE CACHE INTERNAL "Executable required to cache compilations.") endif() diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 488d2a773a..798a903fe1 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -41,6 +41,7 @@ set(SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/analyserequationast.cpp ${CMAKE_CURRENT_SOURCE_DIR}/analyserexternalvariable.cpp ${CMAKE_CURRENT_SOURCE_DIR}/analysermodel.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/analysersymengine.cpp ${CMAKE_CURRENT_SOURCE_DIR}/analyservariable.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotator.cpp ${CMAKE_CURRENT_SOURCE_DIR}/commonutils.cpp @@ -194,14 +195,7 @@ target_include_directories(cellml ${CMAKE_CURRENT_BINARY_DIR} ) -if(HAVE_ZLIB_TARGET) - target_link_libraries(cellml PUBLIC zlib) -else() - target_link_libraries(cellml PUBLIC ${ZLIB_LIBRARIES}) - target_include_directories(cellml PUBLIC ${ZLIB_INCLUDE_DIRS}) -endif() - -target_link_libraries(cellml PUBLIC ${LIBXML2_TARGET} ${ZLIB_TARGET}) +apply_dependency_settings(cellml) # Use target compile features to propagate features to consuming projects. target_compile_features(cellml PUBLIC cxx_std_20) @@ -237,7 +231,7 @@ target_include_directories(cellml_debug_utilities $ ) -target_link_libraries(cellml_debug_utilities PUBLIC ${LIBXML2_TARGET}) +apply_dependency_settings(cellml_debug_utilities) set_target_properties(cellml_debug_utilities PROPERTIES CXX_VISIBILITY_PRESET hidden @@ -281,8 +275,8 @@ function(append_target_property _TARGET _PROPERTY _VALUE) endfunction() if(LIBCELLML_COVERAGE) - append_target_property(cellml COMPILE_FLAGS "-fprofile-arcs -ftest-coverage") - append_target_property(cellml LINK_FLAGS "-fprofile-arcs -ftest-coverage") + target_compile_options(cellml PRIVATE -fprofile-arcs -ftest-coverage) + target_link_options(cellml PUBLIC $) # Share some paths with interested parties (tests) set(GCOV_ANALYSIS_PATH "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/cellml.dir" PARENT_SCOPE) @@ -299,8 +293,8 @@ if(LIBCELLML_COVERAGE) endif() if(LIBCELLML_LLVM_COVERAGE) - append_target_property(cellml COMPILE_FLAGS "-fprofile-instr-generate -fcoverage-mapping") - append_target_property(cellml LINK_FLAGS "-fprofile-instr-generate") + target_compile_options(cellml PRIVATE -fprofile-instr-generate -fcoverage-mapping) + target_link_options(cellml PUBLIC $) endif() install(TARGETS cellml EXPORT libcellml-targets diff --git a/src/analyser.cpp b/src/analyser.cpp index 401936d6f0..85e9e75421 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -20,9 +20,6 @@ limitations under the License. #include "libcellml/analyser.h" -#include -#include - #include "libcellml/analyserequation.h" #include "libcellml/analyserexternalvariable.h" #include "libcellml/analysermodel.h" @@ -39,9 +36,17 @@ limitations under the License. namespace libcellml { +static bool containsInternalVariable(const AnalyserInternalVariablePtrs &variables, + const AnalyserInternalVariablePtr &variable) +{ + return std::any_of(variables.begin(), variables.end(), [&variable](const auto &candidate) { + return candidate == variable; + }); +} + AnalyserInternalVariablePtr AnalyserInternalVariable::create(const VariablePtr &variable) { - auto res = AnalyserInternalVariablePtr {new AnalyserInternalVariable {}}; + auto res = std::make_shared(); res->setVariable(variable); @@ -80,7 +85,9 @@ void AnalyserInternalVariable::makeState() mType = Type::STATE; break; - default: // Other types we don't care about. + default: + // Other types we don't care about. + break; } } @@ -92,7 +99,7 @@ void AnalyserInternalVariable::makeConstant() AnalyserInternalEquationPtr AnalyserInternalEquation::create(const ComponentPtr &component) { - auto res = AnalyserInternalEquationPtr {new AnalyserInternalEquation {}}; + auto res = std::make_shared(); res->mAst = AnalyserEquationAst::create(); res->mComponent = component; @@ -102,18 +109,18 @@ AnalyserInternalEquationPtr AnalyserInternalEquation::create(const ComponentPtr AnalyserInternalEquationPtr AnalyserInternalEquation::create(const AnalyserInternalVariablePtr &variable) { - auto res = AnalyserInternalEquationPtr {new AnalyserInternalEquation {}}; + auto res = std::make_shared(); res->mComponent = owningComponent(variable->mVariable); - res->mUnknownVariables.push_back(variable); + res->addUnknownVariable(variable); return res; } void AnalyserInternalEquation::addVariable(const AnalyserInternalVariablePtr &variable) { - if (std::find(mVariables.begin(), mVariables.end(), variable) == mVariables.end()) { + if (!containsInternalVariable(mVariables, variable)) { mVariables.push_back(variable); mAllVariables.push_back(variable); } @@ -121,252 +128,74 @@ void AnalyserInternalEquation::addVariable(const AnalyserInternalVariablePtr &va void AnalyserInternalEquation::addStateVariable(const AnalyserInternalVariablePtr &stateVariable) { - if (std::find(mStateVariables.begin(), mStateVariables.end(), stateVariable) == mStateVariables.end()) { + if (!containsInternalVariable(mStateVariables, stateVariable)) { mStateVariables.push_back(stateVariable); mAllVariables.push_back(stateVariable); } } -bool AnalyserInternalEquation::isKnownVariable(const AnalyserInternalVariablePtr &variable) -{ - return variable->mType != AnalyserInternalVariable::Type::UNKNOWN; -} - -bool AnalyserInternalEquation::isKnownStateVariable(const AnalyserInternalVariablePtr &stateVariable) -{ - return stateVariable->mIsKnownStateVariable; -} - -bool AnalyserInternalEquation::hasKnownVariables(const AnalyserInternalVariablePtrs &variables) -{ - return std::any_of(variables.begin(), variables.end(), [](const auto &v) { - return isKnownVariable(v); - }); -} - -bool AnalyserInternalEquation::hasKnownVariables() -{ - return hasKnownVariables(mVariables) || hasKnownVariables(mStateVariables); -} - -bool AnalyserInternalEquation::isNonConstantVariable(const AnalyserInternalVariablePtr &variable) +void AnalyserInternalEquation::addUnknownVariable(const AnalyserInternalVariablePtr &unknownVariable) { - // Note: we don't check for AnalyserInternalVariable::Type::CONSTANT because - // a variable's type becomes constant at the very end, i.e. once we - // know for sure that it's neither a state variable nor a variable - // that is computed using an NLA system. - - return variable->mIsExternalVariable - || ((variable->mType != AnalyserInternalVariable::Type::UNKNOWN) - && (variable->mType != AnalyserInternalVariable::Type::INITIALISED) - && (variable->mType != AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT) - && (variable->mType != AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT)); -} - -bool AnalyserInternalEquation::hasNonConstantVariables(const AnalyserInternalVariablePtrs &variables) -{ - return std::any_of(variables.begin(), variables.end(), [](const auto &v) { - return isNonConstantVariable(v); - }); + if (std::find(mUnknownVariables.begin(), mUnknownVariables.end(), unknownVariable) == mUnknownVariables.end()) { + mUnknownVariables.push_back(unknownVariable); + } } -bool AnalyserInternalEquation::hasNonConstantVariables() +bool AnalyserInternalEquation::isVariable(const AnalyserInternalVariablePtr &variable, + const AnalyserEquationAstPtr &astChild) { - return hasNonConstantVariables(mVariables) || hasNonConstantVariables(mStateVariables); -} + VariablePtr astVariable; -bool AnalyserInternalEquation::variableOnLhsRhs(const AnalyserInternalVariablePtr &variable, - const AnalyserEquationAstPtr &astChild) -{ switch (astChild->type()) { case AnalyserEquationAst::Type::CI: - return astChild->variable()->name() == variable->mVariable->name(); + astVariable = astChild->variable(); + + break; case AnalyserEquationAst::Type::DIFF: - return astChild->rightChild()->variable()->name() == variable->mVariable->name(); + astVariable = astChild->rightChild()->variable(); + + break; default: return false; } -} - -bool AnalyserInternalEquation::variableOnRhs(const AnalyserInternalVariablePtr &variable) -{ - return variableOnLhsRhs(variable, mAst->rightChild()); -} -bool AnalyserInternalEquation::variableOnLhsOrRhs(const AnalyserInternalVariablePtr &variable) -{ - return variableOnLhsRhs(variable, mAst->leftChild()) - || variableOnRhs(variable); + return (astVariable == variable->mVariable) || astVariable->hasEquivalentVariable(variable->mVariable); } -bool AnalyserInternalEquation::check(const AnalyserModelPtr &analyserModel, bool checkNlaSystems) +bool AnalyserInternalEquation::containsVariable(const AnalyserInternalVariablePtr &variable, + const AnalyserEquationAstPtr &astChild) { - // Nothing to check if the equation has a known type. - - if (mType != Type::UNKNOWN) { + if (astChild == nullptr) { return false; } - // Determine, from the (new) known (state) variables, whether the equation is - // used to compute a true constant or a variable-based constant. + if ((astChild->type() == AnalyserEquationAst::Type::CI) + && areEquivalentVariables(variable->mVariable, astChild->variable())) { + if (variable->mType == AnalyserInternalVariable::Type::STATE) { + // State variables should be considered known and thus return false if they are used as a typical variable + // (rather than in an ODE). - mComputedTrueConstant = mComputedTrueConstant && !hasKnownVariables(); - mComputedVariableBasedConstant = mComputedVariableBasedConstant && !hasNonConstantVariables(); - - // Add, as a dependency, the variables used to compute the (new) known (state) - // variables. - - for (const auto &variable : mVariables) { - if (isKnownVariable(variable)) { - mDependencies.push_back(variable->mVariable); - } - } - - // Stop tracking (new) known (state) variables. - - mVariables.erase(std::remove_if(mVariables.begin(), mVariables.end(), isKnownVariable), mVariables.end()); - mStateVariables.erase(std::remove_if(mStateVariables.begin(), mStateVariables.end(), isKnownStateVariable), mStateVariables.end()); - - // If there is no (state) variable left then it means that the variables in - // the equation are overconstrained unless one of them was initialised in - // which case it will now be considered as an algebraic variable and this - // equation as an NLA equation. - - auto unknownVariablesOrStateVariablesLeft = mVariables.size() + mStateVariables.size(); - AnalyserInternalVariablePtrs initialisedVariables; - - if (checkNlaSystems && (unknownVariablesOrStateVariablesLeft == 0)) { - for (const auto &variable : mAllVariables) { - switch (variable->mType) { - case AnalyserInternalVariable::Type::INITIALISED: - case AnalyserInternalVariable::Type::INITIALISED_ALGEBRAIC_VARIABLE: - // The equation contains an initialised variable, so track it - // and consider it as an algebraic variable. - - initialisedVariables.push_back(variable); - - variable->mType = AnalyserInternalVariable::Type::INITIALISED_ALGEBRAIC_VARIABLE; - - break; - default: - break; - } + return astChild->parent()->type() == AnalyserEquationAst::Type::DIFF; } - if (initialisedVariables.empty()) { - // The equation doesn't contain any initialised variables, which - // means that it is overconstrained. - - for (const auto &variable : mAllVariables) { - variable->mType = AnalyserInternalVariable::Type::OVERCONSTRAINED; - } - - return false; - } + return true; } - // If there is one (state) variable left (on its own on the LHS/RHS of the - // equation or in case we check for NLA systems) or some initialised - // variables then update its variable (to be the corresponding one in the - // component in which the equation is), as well as set its type (if it is - // currently unknown) and index (if its type is one of the expected ones). - // Finally, set the type and order of the equation, should everything have - // gone as planned. - - auto unknownVariableLeft = (unknownVariablesOrStateVariablesLeft == 1) ? - mVariables.empty() ? - mStateVariables.front() : - mVariables.front() : - nullptr; - - if (((unknownVariableLeft != nullptr) - && (checkNlaSystems || variableOnLhsOrRhs(unknownVariableLeft))) - || !initialisedVariables.empty()) { - auto variables = mVariables.empty() ? - mStateVariables.empty() ? - initialisedVariables : - mStateVariables : - mVariables; - - for (const auto &variable : variables) { - auto i = MAX_SIZE_T; - VariablePtr localVariable; - - do { - localVariable = mComponent->variable(++i); - } while (!analyserModel->areEquivalentVariables(variable->mVariable, localVariable)); - - variable->setVariable(localVariable, false); - - if (variable->mType == AnalyserInternalVariable::Type::UNKNOWN) { - variable->mType = mComputedTrueConstant ? - AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT : - mComputedVariableBasedConstant ? - AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT : - AnalyserInternalVariable::Type::ALGEBRAIC_VARIABLE; - } - - switch (variable->mType) { - case AnalyserInternalVariable::Type::STATE: - case AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT: - case AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT: - case AnalyserInternalVariable::Type::INITIALISED_ALGEBRAIC_VARIABLE: - case AnalyserInternalVariable::Type::ALGEBRAIC_VARIABLE: - variable->mIsKnownStateVariable = variable->mType == AnalyserInternalVariable::Type::STATE; - - mUnknownVariables.push_back(variable); - - break; - default: - return false; - } - } - - // Set the equation's order and type. - // Note: an equation may be used to compute one variable, but if it is - // not on its own on the LHS/RHS of the equation then it needs to - // be solved as an NLA equation. - - if ((unknownVariableLeft == nullptr) - || !variableOnLhsOrRhs(unknownVariableLeft)) { - mType = Type::NLA; - } else { - switch (unknownVariableLeft->mType) { - case AnalyserInternalVariable::Type::STATE: - mType = Type::ODE; - - break; - case AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT: - mType = Type::CONSTANT; - - break; - case AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT: - mType = Type::COMPUTED_CONSTANT; - - break; - default: - mType = Type::ALGEBRAIC; - - break; - } - } - - // An ODE equation may have a dependency on the state of that ODE (e.g., - // dx/dt = x+3). Similarly, an NLA equation will have a "dependency" on - // its unknown variables. Either way, we must remove our "dependencies" - // on our unknown variables or we will end up in a circular dependency. - - for (const auto &unknownVariable : mUnknownVariables) { - auto it = std::find(mDependencies.begin(), mDependencies.end(), unknownVariable->mVariable); + return containsVariable(variable, astChild->leftChild()) || containsVariable(variable, astChild->rightChild()); +} - if (it != mDependencies.end()) { - mDependencies.erase(it); - } - } +bool AnalyserInternalEquation::isVariableIsolated(const AnalyserInternalVariablePtr &variable) +{ + if (isVariable(variable, mAst->leftChild())) { + return !containsVariable(variable, mAst->rightChild()); + } - return true; + if (isVariable(variable, mAst->rightChild())) { + return !containsVariable(variable, mAst->leftChild()); } + // The variable is not isolated on either side. + return false; } @@ -398,6 +227,30 @@ Analyser::AnalyserImpl::AnalyserImpl() mGeneratorProfile->setNanString("notanumber"); } +Analyser::AnalyserImpl::~AnalyserImpl() +{ + // "Reset" ourselves to break the shared_ptr cycles between internal equations and variables so that they can be properly cleaned up. + + reset(); +} + +void Analyser::AnalyserImpl::reset() +{ + for (const auto &internalVariable : mInternalVariables) { + internalVariable->mMatchedEquation.reset(); + internalVariable->mUnmatchedEquations.clear(); + } + + mFirstVariables.clear(); + mLastVariables.clear(); + + mInternalVariables.clear(); + mInternalVariableMap.clear(); + mInternalEquations.clear(); + + mCiCnUnits.clear(); +} + AnalyserInternalVariablePtr Analyser::AnalyserImpl::internalVariable(const VariablePtr &variable) { // Find and return, if there is one, the internal variable associated with @@ -466,8 +319,11 @@ void Analyser::AnalyserImpl::analyseNode(const XmlNodePtr &node, } // Basic content elements. + // Note: we don't need to check for the MathML namespace here since we can only analyse if a model is valid. + + const char *elemName = node->rawName(); - if (node->isMathmlElement("apply")) { + if (strcmp(elemName, "apply") == 0) { // We may have 1, 2, 3 or more child nodes, e.g. // // +--------+ @@ -526,7 +382,7 @@ void Analyser::AnalyserImpl::analyseNode(const XmlNodePtr &node, // Relational and logical operators. - } else if (node->isMathmlElement("eq")) { + } else if (strcmp(elemName, "eq") == 0) { // This element is used both to describe "a = b" and "a == b". We can // distinguish between the two by checking its grandparent. If it's a // "math" element then it means that it is used to describe "a = b" @@ -539,163 +395,163 @@ void Analyser::AnalyserImpl::analyseNode(const XmlNodePtr &node, mAnalyserModel->mPimpl->mNeedEqFunction = true; } - } else if (node->isMathmlElement("neq")) { + } else if (strcmp(elemName, "neq") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::NEQ, astParent); mAnalyserModel->mPimpl->mNeedNeqFunction = true; - } else if (node->isMathmlElement("lt")) { + } else if (strcmp(elemName, "lt") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::LT, astParent); mAnalyserModel->mPimpl->mNeedLtFunction = true; - } else if (node->isMathmlElement("leq")) { + } else if (strcmp(elemName, "leq") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::LEQ, astParent); mAnalyserModel->mPimpl->mNeedLeqFunction = true; - } else if (node->isMathmlElement("gt")) { + } else if (strcmp(elemName, "gt") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::GT, astParent); mAnalyserModel->mPimpl->mNeedGtFunction = true; - } else if (node->isMathmlElement("geq")) { + } else if (strcmp(elemName, "geq") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::GEQ, astParent); mAnalyserModel->mPimpl->mNeedGeqFunction = true; - } else if (node->isMathmlElement("and")) { + } else if (strcmp(elemName, "and") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::AND, astParent); mAnalyserModel->mPimpl->mNeedAndFunction = true; - } else if (node->isMathmlElement("or")) { + } else if (strcmp(elemName, "or") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::OR, astParent); mAnalyserModel->mPimpl->mNeedOrFunction = true; - } else if (node->isMathmlElement("xor")) { + } else if (strcmp(elemName, "xor") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::XOR, astParent); mAnalyserModel->mPimpl->mNeedXorFunction = true; - } else if (node->isMathmlElement("not")) { + } else if (strcmp(elemName, "not") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::NOT, astParent); mAnalyserModel->mPimpl->mNeedNotFunction = true; // Arithmetic operators. - } else if (node->isMathmlElement("plus")) { + } else if (strcmp(elemName, "plus") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::PLUS, astParent); - } else if (node->isMathmlElement("minus")) { + } else if (strcmp(elemName, "minus") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::MINUS, astParent); - } else if (node->isMathmlElement("times")) { + } else if (strcmp(elemName, "times") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::TIMES, astParent); - } else if (node->isMathmlElement("divide")) { + } else if (strcmp(elemName, "divide") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::DIVIDE, astParent); - } else if (node->isMathmlElement("power")) { + } else if (strcmp(elemName, "power") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::POWER, astParent); - } else if (node->isMathmlElement("root")) { + } else if (strcmp(elemName, "root") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::ROOT, astParent); - } else if (node->isMathmlElement("abs")) { + } else if (strcmp(elemName, "abs") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::ABS, astParent); - } else if (node->isMathmlElement("exp")) { + } else if (strcmp(elemName, "exp") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::EXP, astParent); - } else if (node->isMathmlElement("ln")) { + } else if (strcmp(elemName, "ln") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::LN, astParent); - } else if (node->isMathmlElement("log")) { + } else if (strcmp(elemName, "log") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::LOG, astParent); - } else if (node->isMathmlElement("ceiling")) { + } else if (strcmp(elemName, "ceiling") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::CEILING, astParent); - } else if (node->isMathmlElement("floor")) { + } else if (strcmp(elemName, "floor") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::FLOOR, astParent); - } else if (node->isMathmlElement("min")) { + } else if (strcmp(elemName, "min") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::MIN, astParent); mAnalyserModel->mPimpl->mNeedMinFunction = true; - } else if (node->isMathmlElement("max")) { + } else if (strcmp(elemName, "max") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::MAX, astParent); mAnalyserModel->mPimpl->mNeedMaxFunction = true; - } else if (node->isMathmlElement("rem")) { + } else if (strcmp(elemName, "rem") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::REM, astParent); // Calculus elements. - } else if (node->isMathmlElement("diff")) { + } else if (strcmp(elemName, "diff") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::DIFF, astParent); // Trigonometric operators. - } else if (node->isMathmlElement("sin")) { + } else if (strcmp(elemName, "sin") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::SIN, astParent); - } else if (node->isMathmlElement("cos")) { + } else if (strcmp(elemName, "cos") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::COS, astParent); - } else if (node->isMathmlElement("tan")) { + } else if (strcmp(elemName, "tan") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::TAN, astParent); - } else if (node->isMathmlElement("sec")) { + } else if (strcmp(elemName, "sec") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::SEC, astParent); mAnalyserModel->mPimpl->mNeedSecFunction = true; - } else if (node->isMathmlElement("csc")) { + } else if (strcmp(elemName, "csc") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::CSC, astParent); mAnalyserModel->mPimpl->mNeedCscFunction = true; - } else if (node->isMathmlElement("cot")) { + } else if (strcmp(elemName, "cot") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::COT, astParent); mAnalyserModel->mPimpl->mNeedCotFunction = true; - } else if (node->isMathmlElement("sinh")) { + } else if (strcmp(elemName, "sinh") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::SINH, astParent); - } else if (node->isMathmlElement("cosh")) { + } else if (strcmp(elemName, "cosh") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::COSH, astParent); - } else if (node->isMathmlElement("tanh")) { + } else if (strcmp(elemName, "tanh") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::TANH, astParent); - } else if (node->isMathmlElement("sech")) { + } else if (strcmp(elemName, "sech") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::SECH, astParent); mAnalyserModel->mPimpl->mNeedSechFunction = true; - } else if (node->isMathmlElement("csch")) { + } else if (strcmp(elemName, "csch") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::CSCH, astParent); mAnalyserModel->mPimpl->mNeedCschFunction = true; - } else if (node->isMathmlElement("coth")) { + } else if (strcmp(elemName, "coth") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::COTH, astParent); mAnalyserModel->mPimpl->mNeedCothFunction = true; - } else if (node->isMathmlElement("arcsin")) { + } else if (strcmp(elemName, "arcsin") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::ASIN, astParent); - } else if (node->isMathmlElement("arccos")) { + } else if (strcmp(elemName, "arccos") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::ACOS, astParent); - } else if (node->isMathmlElement("arctan")) { + } else if (strcmp(elemName, "arctan") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::ATAN, astParent); - } else if (node->isMathmlElement("arcsec")) { + } else if (strcmp(elemName, "arcsec") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::ASEC, astParent); mAnalyserModel->mPimpl->mNeedAsecFunction = true; - } else if (node->isMathmlElement("arccsc")) { + } else if (strcmp(elemName, "arccsc") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::ACSC, astParent); mAnalyserModel->mPimpl->mNeedAcscFunction = true; - } else if (node->isMathmlElement("arccot")) { + } else if (strcmp(elemName, "arccot") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::ACOT, astParent); mAnalyserModel->mPimpl->mNeedAcotFunction = true; - } else if (node->isMathmlElement("arcsinh")) { + } else if (strcmp(elemName, "arcsinh") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::ASINH, astParent); - } else if (node->isMathmlElement("arccosh")) { + } else if (strcmp(elemName, "arccosh") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::ACOSH, astParent); - } else if (node->isMathmlElement("arctanh")) { + } else if (strcmp(elemName, "arctanh") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::ATANH, astParent); - } else if (node->isMathmlElement("arcsech")) { + } else if (strcmp(elemName, "arcsech") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::ASECH, astParent); mAnalyserModel->mPimpl->mNeedAsechFunction = true; - } else if (node->isMathmlElement("arccsch")) { + } else if (strcmp(elemName, "arccsch") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::ACSCH, astParent); mAnalyserModel->mPimpl->mNeedAcschFunction = true; - } else if (node->isMathmlElement("arccoth")) { + } else if (strcmp(elemName, "arccoth") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::ACOTH, astParent); mAnalyserModel->mPimpl->mNeedAcothFunction = true; // Piecewise statement. - } else if (node->isMathmlElement("piecewise")) { + } else if (strcmp(elemName, "piecewise") == 0) { auto childCount = mathmlChildCount(node); ast->mPimpl->populate(AnalyserEquationAst::Type::PIECEWISE, astParent); @@ -725,19 +581,19 @@ void Analyser::AnalyserImpl::analyseNode(const XmlNodePtr &node, ast->mPimpl->mOwnedRightChild = astRight; } - } else if (node->isMathmlElement("piece")) { + } else if (strcmp(elemName, "piece") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::PIECE, astParent); analyseNode(mathmlChildNode(node, 0), ast->mPimpl->mOwnedLeftChild, ast, component, equation); analyseNode(mathmlChildNode(node, 1), ast->mPimpl->mOwnedRightChild, ast, component, equation); - } else if (node->isMathmlElement("otherwise")) { + } else if (strcmp(elemName, "otherwise") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::OTHERWISE, astParent); analyseNode(mathmlChildNode(node, 0), ast->mPimpl->mOwnedLeftChild, ast, component, equation); // Token elements. - } else if (node->isMathmlElement("ci")) { + } else if (strcmp(elemName, "ci") == 0) { auto variableName = node->firstChild()->convertToStrippedString(); auto variable = component->variable(variableName); // Note: we always have a variable. Indeed, if we were not to have one, @@ -760,7 +616,7 @@ void Analyser::AnalyserImpl::analyseNode(const XmlNodePtr &node, ast->mPimpl->populate(AnalyserEquationAst::Type::CI, variable, astParent); mCiCnUnits.emplace(ast, variable->units()); - } else if (node->isMathmlElement("cn")) { + } else if (strcmp(elemName, "cn") == 0) { // Add the number to our AST and keep track of its unit. Note that in // the case of a standard unit, we need to create a units since it's // not declared in the model. @@ -792,15 +648,15 @@ void Analyser::AnalyserImpl::analyseNode(const XmlNodePtr &node, // Qualifier elements. - } else if (node->isMathmlElement("degree")) { + } else if (strcmp(elemName, "degree") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::DEGREE, astParent); analyseNode(mathmlChildNode(node, 0), ast->mPimpl->mOwnedLeftChild, ast, component, equation); - } else if (node->isMathmlElement("logbase")) { + } else if (strcmp(elemName, "logbase") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::LOGBASE, astParent); analyseNode(mathmlChildNode(node, 0), ast->mPimpl->mOwnedLeftChild, ast, component, equation); - } else if (node->isMathmlElement("bvar")) { + } else if (strcmp(elemName, "bvar") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::BVAR, astParent); analyseNode(mathmlChildNode(node, 0), ast->mPimpl->mOwnedLeftChild, ast, component, equation); @@ -813,15 +669,15 @@ void Analyser::AnalyserImpl::analyseNode(const XmlNodePtr &node, // Constants. - } else if (node->isMathmlElement("true")) { + } else if (strcmp(elemName, "true") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::TRUE, astParent); - } else if (node->isMathmlElement("false")) { + } else if (strcmp(elemName, "false") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::FALSE, astParent); - } else if (node->isMathmlElement("exponentiale")) { + } else if (strcmp(elemName, "exponentiale") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::E, astParent); - } else if (node->isMathmlElement("pi")) { + } else if (strcmp(elemName, "pi") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::PI, astParent); - } else if (node->isMathmlElement("infinity")) { + } else if (strcmp(elemName, "infinity") == 0) { ast->mPimpl->populate(AnalyserEquationAst::Type::INF, astParent); } else { // We have checked for everything, so if we reach this point it means @@ -962,29 +818,6 @@ void Analyser::AnalyserImpl::analyseComponentVariables(const ComponentPtr &compo } } -void Analyser::AnalyserImpl::equivalentVariables(const VariablePtr &variable, - VariablePtrs &equivVariables) const -{ - for (size_t i = 0; i < variable->equivalentVariableCount(); ++i) { - auto equivVariable = variable->equivalentVariable(i); - - if (std::find(equivVariables.begin(), equivVariables.end(), equivVariable) == equivVariables.end()) { - equivVariables.push_back(equivVariable); - - equivalentVariables(equivVariable, equivVariables); - } - } -} - -VariablePtrs Analyser::AnalyserImpl::equivalentVariables(const VariablePtr &variable) const -{ - VariablePtrs res = {variable}; - - equivalentVariables(variable, res); - - return res; -} - void Analyser::AnalyserImpl::analyseEquationAst(const AnalyserEquationAstPtr &ast) { // Make sure that we have an AST to analyse. @@ -1519,13 +1352,11 @@ double Analyser::AnalyserImpl::powerValue(const AnalyserEquationAstPtr &ast, return std::log(lhs); case AnalyserEquationAst::Type::LOG: if (ast->mPimpl->mOwnedLeftChild->type() == AnalyserEquationAst::Type::LOGBASE) { - auto logBase = lhs; - - if (areNearlyEqual(logBase, 10.0)) { + if (areNearlyEqual(lhs, 10.0)) { return std::log10(rhs); } - return std::log(rhs) / std::log(logBase); + return std::log(rhs) / std::log(lhs); } return std::log10(lhs); @@ -2156,7 +1987,9 @@ void Analyser::AnalyserImpl::analyseEquationUnits(const AnalyserEquationAstPtr & defaultUnitsMapsAndMultipliers(unitsMaps, userUnitsMaps, unitsMultipliers); break; - default: // Other types we don't care about. + default: + // Other types we don't care about. + break; } } @@ -2256,28 +2089,15 @@ void Analyser::AnalyserImpl::scaleEquationAst(const AnalyserEquationAstPtr &ast) } } -bool Analyser::AnalyserImpl::isExternalVariable(const AnalyserInternalVariablePtr &variable) -{ - return variable->mIsExternalVariable; -} - bool Analyser::AnalyserImpl::isStateRateBased(const AnalyserEquationPtr &analyserEquation, - AnalyserEquationPtrs &checkedEquations) + std::unordered_set &checkedEquations) { - if (std::find(checkedEquations.begin(), checkedEquations.end(), analyserEquation) != checkedEquations.end()) { + if (!checkedEquations.insert(analyserEquation.get()).second) { return false; } - checkedEquations.push_back(analyserEquation); - for (const auto &dependency : analyserEquation->dependencies()) { - // A rate is computed either through an ODE equation or through an NLA - // equation in case the rate is not on its own on either the LHS or RHS - // of the equation. - if ((dependency->type() == AnalyserEquation::Type::ODE) - || ((dependency->type() == AnalyserEquation::Type::NLA) - && (dependency->stateCount() == 1)) || isStateRateBased(dependency, checkedEquations)) { return true; } @@ -2326,16 +2146,13 @@ void Analyser::AnalyserImpl::addInvalidVariableIssue(const AnalyserInternalVaria void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) { - // Reset a few things in case this analyser was to be used to analyse more - // than one model. + // Reset a few things in case this analyser was to be used to analyse more than one model. - mAnalyserModel = AnalyserModel::AnalyserModelImpl::create(model); + reset(); - mInternalVariables.clear(); - mInternalVariableMap.clear(); - mInternalEquations.clear(); + // Create the analyser model. - mCiCnUnits.clear(); + mAnalyserModel = AnalyserModel::AnalyserModelImpl::create(model); // Recursively analyse the model's components, so that we end up with an AST // for each of the model's equations. @@ -2366,7 +2183,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Mark some variables as external variables, should there be some and // should they belong to the model being analysed. - std::map primaryExternalVariables; + std::unordered_map primaryExternalVariables; if (!mExternalVariables.empty()) { for (const auto &externalVariable : mExternalVariables) { @@ -2392,7 +2209,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) internalVariable->mIsExternalVariable = true; for (const auto &dependency : externalVariable->dependencies()) { - internalVariable->mDependencies.push_back(Analyser::AnalyserImpl::internalVariable(dependency)->mVariable); + internalVariable->mDependencies.push_back(Analyser::AnalyserImpl::internalVariable(dependency)); } } } @@ -2414,6 +2231,8 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Check that the variables that were marked as external were rightly so. + bool hasInvalidVoiExternalVariable = false; + for (const auto &primaryExternalVariable : primaryExternalVariables) { std::string description; auto isVoi = (mAnalyserModel->mPimpl->mVoi != nullptr) @@ -2459,6 +2278,8 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) description += " variable of integration which cannot be used as an external variable."; referenceRule = Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_VOI; + + hasInvalidVoiExternalVariable = true; } else { description += (equivalentVariableCount == 1) ? " is marked as an external variable, but it is not a primary variable." : @@ -2489,6 +2310,12 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) } } + if (hasInvalidVoiExternalVariable) { + mAnalyserModel->mPimpl->mType = AnalyserModel::Type::INVALID; + + return; + } + // Analyse our different equations' units to make sure that everything is // consistent. @@ -2519,113 +2346,71 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) return iv->mIsExternalVariable; }); - // Loop over our equations, checking which variables, if any, can be - // determined using a given equation. - // Note: we loop twice by checking the model with the view of: - // 1) getting an ODE system WITHOUT any NLA systems; and then - // 2) getting an ODE system WITH one or several NLA systems. - // After those two loops, if we still have some unknown variables and - // they have been marked as external, then we consider them as - // initialised and we go through the two loops one more time. This is - // to account for models that have unknown variables (rendering the - // model invalid) that have been marked as external (rendering the - // model valid). - - auto loopNumber = 1; - bool relevantCheck; - auto checkNlaSystems = false; - - do { - relevantCheck = false; + // Remove any equations that define an external state variable. Indeed, they are not used to compute internal + // variables since the state variable is supplied externally. - for (const auto &internalEquation : mInternalEquations) { - relevantCheck = internalEquation->check(mAnalyserModel, checkNlaSystems) - || relevantCheck; - } + mInternalEquations.erase( + std::remove_if(mInternalEquations.begin(), mInternalEquations.end(), [](const auto &e) { + return std::any_of(e->mStateVariables.begin(), e->mStateVariables.end(), [](const auto &sv) { + return sv->mIsExternalVariable; + }); + }), + mInternalEquations.end()); - if (((loopNumber == 1) || (loopNumber == 3)) && !relevantCheck) { - ++loopNumber; + // Initialise the variables and the equations that we have to match. + // Note: the VOI and initialised variables (i.e. constants and state variables, normally) are not included since + // they are expected to be known and therefore don't need to be matched. - relevantCheck = true; - checkNlaSystems = true; - } else if ((loopNumber == 2) && !relevantCheck) { - // We have gone through the two loops and we still have some unknown - // variables, so we consider as initialised those that have been - // marked as external and we go through the two loops one more time. + AnalyserInternalVariablePtrs unknownVariables; + AnalyserInternalEquationPtrs unknownEquations = mInternalEquations; - for (const auto &internalVariable : mInternalVariables) { - if (internalVariable->mIsExternalVariable - && (internalVariable->mType == AnalyserInternalVariable::Type::UNKNOWN)) { - internalVariable->mType = AnalyserInternalVariable::Type::INITIALISED; - } - } + std::copy_if(mInternalVariables.begin(), mInternalVariables.end(), + std::back_inserter(unknownVariables), + [](const auto &v) { + return (v->mType != AnalyserInternalVariable::Type::VARIABLE_OF_INTEGRATION) + && (v->mType != AnalyserInternalVariable::Type::INITIALISED); + }); - if (hasExternalVariables) { - ++loopNumber; + AnalyserInternalVariablePtrs structuralUnknownVariables; - relevantCheck = true; - checkNlaSystems = false; - } - } - } while (relevantCheck); + std::copy_if(unknownVariables.begin(), unknownVariables.end(), std::back_inserter(structuralUnknownVariables), + [](const auto &uv) { + return !uv->mIsExternalVariable; + }); - // Make sure that our variables are valid. + // Generate the SymEngine equivalent of our unknown equations. - for (const auto &internalVariable : mInternalVariables) { - switch (internalVariable->mType) { - case AnalyserInternalVariable::Type::UNKNOWN: - addInvalidVariableIssue(internalVariable, Issue::ReferenceRule::ANALYSER_VARIABLE_UNUSED); + for (const auto &unknownEquation : unknownEquations) { + auto [success, seExpression] = astToSymEngine(unknownEquation->mAst); - break; - case AnalyserInternalVariable::Type::SHOULD_BE_STATE: - addInvalidVariableIssue(internalVariable, Issue::ReferenceRule::ANALYSER_STATE_NOT_INITIALISED); + if (success) { + unknownEquation->mSEExpression = seExpression; + } + } - break; - case AnalyserInternalVariable::Type::INITIALISED: - // The variable is (still) initialised so it has to be a constant. + // Match our unknown variables and equations, substitute the matched variables in the matched equations, and + // classify the variables and equations that we have matched so far. - internalVariable->makeConstant(); + matchVariablesAndEquations(unknownVariables, unknownEquations); - break; - case AnalyserInternalVariable::Type::OVERCONSTRAINED: - addInvalidVariableIssue(internalVariable, Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED); + substituteVariablesInEquations(); + classifyVariablesAndEquations(); - break; - default: // Other types we don't care about. - break; - } - } + // Make sure that our variables are valid. - if (mAnalyser->errorCount() != 0) { - auto hasUnderconstrainedVariables = std::any_of(mInternalVariables.begin(), mInternalVariables.end(), [](const auto &iv) { - switch (iv->mType) { - case AnalyserInternalVariable::Type::UNKNOWN: - case AnalyserInternalVariable::Type::SHOULD_BE_STATE: - return true; - default: - return false; - } - }); - auto hasOverconstrainedVariables = std::any_of(mInternalVariables.begin(), mInternalVariables.end(), [](const auto &iv) { - return iv->mType == AnalyserInternalVariable::Type::OVERCONSTRAINED; - }); + for (const auto &internalVariable : mInternalVariables) { + if (internalVariable->mType == AnalyserInternalVariable::Type::INITIALISED) { + // The variable is (still) initialised so it has to be a constant. - if (hasUnderconstrainedVariables) { - if (hasOverconstrainedVariables) { - mAnalyserModel->mPimpl->mType = AnalyserModel::Type::UNSUITABLY_CONSTRAINED; - } else { - mAnalyserModel->mPimpl->mType = AnalyserModel::Type::UNDERCONSTRAINED; - } - } else { - mAnalyserModel->mPimpl->mType = AnalyserModel::Type::OVERCONSTRAINED; + internalVariable->makeConstant(); } - - return; } // Make sure that variables that are initialised using another variable are // not initialised using an algebraic variable. + const auto origErrorCount = mAnalyser->errorCount(); + for (const auto &internalVariable : mInternalVariables) { if ((internalVariable->mInitialisingVariable != nullptr) && !isCellMLReal(internalVariable->mInitialisingVariable->initialValue())) { @@ -2646,7 +2431,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) } } - if (mAnalyser->errorCount() != 0) { + if (mAnalyser->errorCount() != origErrorCount) { mAnalyserModel->mPimpl->mType = AnalyserModel::Type::INVALID; return; @@ -2666,63 +2451,86 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // equation can have a dependency on them. if (internalEquation->mType == AnalyserInternalEquation::Type::NLA) { + AnalyserInternalVariablePtrs externalUnknownVariables; + for (const auto &unknownVariable : internalEquation->mUnknownVariables) { if (unknownVariable->mIsExternalVariable - && (std::find(addedExternalVariables.begin(), addedExternalVariables.end(), unknownVariable) == addedExternalVariables.end())) { + && !containsInternalVariable(addedExternalVariables, unknownVariable)) { addedExternalVariables.push_back(unknownVariable); addedInternalEquations.push_back(AnalyserInternalEquation::create(unknownVariable)); } + + if (unknownVariable->mIsExternalVariable) { + externalUnknownVariables.push_back(unknownVariable); + } } - internalEquation->mUnknownVariables.erase(std::remove_if(internalEquation->mUnknownVariables.begin(), internalEquation->mUnknownVariables.end(), isExternalVariable), internalEquation->mUnknownVariables.end()); + internalEquation->mUnknownVariables.erase(std::remove_if(internalEquation->mUnknownVariables.begin(), internalEquation->mUnknownVariables.end(), + [&externalUnknownVariables](const auto &uv) { + return std::find(externalUnknownVariables.begin(), externalUnknownVariables.end(), uv) != externalUnknownVariables.end(); + }), + internalEquation->mUnknownVariables.end()); } - // Discard the equation if we have no unknown variables left. + // Discard the equation if we have no unknown variables left and it does not contain any remaining dependencies. + // Otherwise, keep it as a constraint on known variables. - if (internalEquation->mUnknownVariables.empty()) { + if (internalEquation->mUnknownVariables.empty() + && internalEquation->mDependencies.empty()) { removedInternalEquations.push_back(internalEquation); } + } - // Make the NLA equations that compute the same variables aware of one - // another and assign them an index for the NLA system in which they are - // used. + for (const auto &internalEquation : mInternalEquations) { + if (internalEquation->mType != AnalyserInternalEquation::Type::NLA) { + continue; + } - if (internalEquation->mType == AnalyserInternalEquation::Type::NLA) { - if (internalEquation->mNlaSystemIndex == MAX_SIZE_T) { - internalEquation->mNlaSystemIndex = ++nlaSystemIndex; + if (internalEquation->mNlaSystemIndex == MAX_SIZE_T) { + internalEquation->mNlaSystemIndex = ++nlaSystemIndex; + } + + std::unordered_set internalEquationVariablesSet; + + internalEquationVariablesSet.reserve(internalEquation->mUnknownVariables.size() + internalEquation->mDependencies.size()); + + for (const auto &unknownVariable : internalEquation->mUnknownVariables) { + internalEquationVariablesSet.insert(unknownVariable.get()); + } + + for (const auto &dependency : internalEquation->mDependencies) { + if (!dependency->mIsExternalVariable + && (dependency->mType != AnalyserInternalVariable::Type::CONSTANT) + && (dependency->mType != AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT) + && (dependency->mType != AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT)) { + internalEquationVariablesSet.insert(dependency.get()); } + } - for (const auto &otherInternalEquation : mInternalEquations) { - if ((otherInternalEquation != internalEquation) - && (otherInternalEquation->mType == AnalyserInternalEquation::Type::NLA)) { - // Check what common unknown variables there are between - // internalEquation and otherInternalEquation, if any. - // Note: we would normally use std::set_intersection() for - // this, but this would require - // internalEquation->mUnknownVariables and - // otherInternalEquation->mUnknownVariables to be - // sorted which neither of them is and it's not worth - // sorting them for such a trivial case, hence we do - // the intersection ourselves. - - AnalyserInternalVariablePtrs commonUnknownVariables; + for (const auto &otherInternalEquation : mInternalEquations) { + if ((otherInternalEquation != internalEquation) + && (otherInternalEquation->mType == AnalyserInternalEquation::Type::NLA)) { + // Check what common variables there are between internalEquation and otherInternalEquation, if any. + // Note: we would normally use std::set_intersection() for this, but this would require both sets to be + // sorted. Since they are not, we use a hash set instead. - for (const auto &unknownVariable : internalEquation->mUnknownVariables) { - if (std::find(otherInternalEquation->mUnknownVariables.begin(), otherInternalEquation->mUnknownVariables.end(), unknownVariable) != otherInternalEquation->mUnknownVariables.end()) { - commonUnknownVariables.push_back(unknownVariable); - } + bool hasCommonVariables = false; + + for (const auto &unknownVariable : otherInternalEquation->mUnknownVariables) { + if (internalEquationVariablesSet.count(unknownVariable.get()) != 0) { + hasCommonVariables = true; + + break; } + } - // Consider otherInternalEquation as an NLA sibling of - // internalEquation, if there are some common unknown - // variables, and make sure that it has the same NLA system - // index as internalEquation. + // Consider otherInternalEquation as an NLA sibling of internalEquation if there are some common + // variables, and make sure that it has the same NLA system index as internalEquation. - if (!commonUnknownVariables.empty()) { - internalEquation->mNlaSiblings.push_back(otherInternalEquation); + if (hasCommonVariables) { + internalEquation->mNlaSiblings.push_back(otherInternalEquation); - otherInternalEquation->mNlaSystemIndex = internalEquation->mNlaSystemIndex; - } + otherInternalEquation->mNlaSystemIndex = internalEquation->mNlaSystemIndex; } } } @@ -2730,93 +2538,180 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Add/remove some internal equations. - for (const auto &addedInternalEquation : addedInternalEquations) { - mInternalEquations.push_back(addedInternalEquation); + if (!addedInternalEquations.empty()) { + mInternalEquations.insert(mInternalEquations.end(), addedInternalEquations.begin(), addedInternalEquations.end()); } - for (const auto &removedInternalEquation : removedInternalEquations) { - mInternalEquations.erase(std::find(mInternalEquations.begin(), mInternalEquations.end(), removedInternalEquation)); - } + if (!removedInternalEquations.empty()) { + const std::unordered_set removedEquationSet( + removedInternalEquations.begin(), removedInternalEquations.end()); - // Confirm that equations that compute a variable-based constant are still - // of that type. - // Note: indeed, when originally qualifying such an equation, all we know - // about the variables on which the equation depends is that they have - // an initial value. However, those variables may then have been - // proven to be computed using an NLA system, in which case the - // equation should now be considered as an algebraic equation and the - // variable it computes an algebraic variable. + mInternalEquations.erase( + std::remove_if(mInternalEquations.begin(), mInternalEquations.end(), + [&removedEquationSet](const auto &equation) { + return removedEquationSet.count(equation); + }), + mInternalEquations.end()); + } // Confirm that the variables in an NLA system are not overconstrained. - // Note: this may happen if an NLA system contains too many NLA equations - // to compute its unknown variables and/or if some internal equations - // were removed (as a result of some variables in an NLA equation - // having been marked as external). + // Note: this may happen if an NLA system contains too many NLA equations to compute its unknown variables and/or if + // some internal equations were removed (as a result of some variables in an NLA equation having been marked + // as external). - AnalyserInternalVariablePtrs underconstrainedVariables; - AnalyserInternalVariablePtrs overconstrainedVariables; + std::unordered_set underconstrainedVariablesSet; + std::unordered_set overconstrainedVariablesSet; for (const auto &internalEquation : mInternalEquations) { switch (internalEquation->mType) { - case AnalyserInternalEquation::Type::COMPUTED_CONSTANT: { - auto unknownVariable = internalEquation->mUnknownVariables.front(); + case AnalyserInternalEquation::Type::NLA: { + const auto markVariableAsUnderconstrained = [&](const AnalyserInternalVariablePtr &variable) { + if (underconstrainedVariablesSet.insert(variable.get()).second) { + variable->mType = AnalyserInternalVariable::Type::UNDERCONSTRAINED; + } + }; + + std::unordered_set nlaSystemUnknownVariables; + const auto isNlaSystemUnknownVariable = [&](const AnalyserInternalVariablePtr &v) { + return !v->mIsExternalVariable + && (v->mType != AnalyserInternalVariable::Type::STATE) + && (v->mType != AnalyserInternalVariable::Type::CONSTANT) + && (v->mType != AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT) + && (v->mType != AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT) + && (v->mType != AnalyserInternalVariable::Type::OVERCONSTRAINED); + }; + const auto addNlaSystemUnknowns = [&](const AnalyserInternalEquationPtr &ie) { + for (const auto &unknownVariable : ie->mUnknownVariables) { + if (isNlaSystemUnknownVariable(unknownVariable)) { + nlaSystemUnknownVariables.insert(unknownVariable.get()); + } + } - for (const auto &variable : internalEquation->mAllVariables) { - if ((variable != unknownVariable) - && (variable->mType != AnalyserInternalVariable::Type::CONSTANT) - && (variable->mType != AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT) - && (variable->mType != AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT)) { - // We are supposed to compute a variable-based constant, yet - // we have come across a variable which is not some kind of - // a constant. In fact, it was an algebraic variable (with - // an initial guess) that needs to be computed using an NLA - // system. So, requalify the unknown variable and equation. - - unknownVariable->mType = AnalyserInternalVariable::Type::ALGEBRAIC_VARIABLE; - internalEquation->mType = AnalyserInternalEquation::Type::ALGEBRAIC; - - break; + for (const auto &dependency : ie->mDependencies) { + if (isNlaSystemUnknownVariable(dependency)) { + nlaSystemUnknownVariables.insert(dependency.get()); + } } + }; + + addNlaSystemUnknowns(internalEquation); + + for (const auto &nlaSibling : internalEquation->mNlaSiblings) { + addNlaSystemUnknowns(nlaSibling.lock()); } - } break; - case AnalyserInternalEquation::Type::NLA: - 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; + const auto nlaSiblingCount = internalEquation->mNlaSiblings.size() + 1; // +1 to account for internalEquation itself. + const auto nlaSystemUnknownVariableCount = nlaSystemUnknownVariables.size(); - addInvalidVariableIssue(unknownVariable, Issue::ReferenceRule::ANALYSER_VARIABLE_UNDERCONSTRAINED); + if (nlaSiblingCount < nlaSystemUnknownVariableCount) { + // There are fewer NLA equations than unknown variables, so all the variables involved in the NLA system + // should be considered as underconstrained. - underconstrainedVariables.push_back(unknownVariable); + for (const auto &variable : internalEquation->mAllVariables) { + markVariableAsUnderconstrained(variable); + } + } else if (nlaSiblingCount > nlaSystemUnknownVariableCount) { + // There are more NLA equations than unknown variables, so the NLA system should be considered as + // overconstrained. + // Note: this can still happen for equations that have no unknown variables left because the variables + // they depend on are already known. + + const auto markVariableAsOverconstrained = [&](const AnalyserInternalVariablePtr &variable) { + if (overconstrainedVariablesSet.insert(variable.get()).second) { + variable->mType = AnalyserInternalVariable::Type::OVERCONSTRAINED; + } + }; + + if (internalEquation->mUnknownVariables.empty()) { + for (const auto &dependency : internalEquation->mDependencies) { + markVariableAsOverconstrained(dependency); + } + } else { + for (const auto &unknownVariable : internalEquation->mUnknownVariables) { + markVariableAsOverconstrained(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. + } + } + + break; + default: + // Other types we don't care about. - for (const auto &unknownVariable : internalEquation->mUnknownVariables) { - if (std::find(overconstrainedVariables.begin(), overconstrainedVariables.end(), unknownVariable) == overconstrainedVariables.end()) { - unknownVariable->mType = AnalyserInternalVariable::Type::OVERCONSTRAINED; + break; + } + } - addInvalidVariableIssue(unknownVariable, Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED); + // If an equation still contains some unknown variables then those unknown variables should be marked as underconstrained. - overconstrainedVariables.push_back(unknownVariable); - } + for (const auto &internalEquation : mInternalEquations) { + if (internalEquation->mType == AnalyserInternalEquation::Type::COMPUTED_CONSTANT) { + continue; + } + + auto hasUnknownVariable = std::any_of(internalEquation->mAllVariables.begin(), internalEquation->mAllVariables.end(), [](const auto &v) { + return v->mType == AnalyserInternalVariable::Type::UNKNOWN; + }); + + if (hasUnknownVariable) { + for (const auto &variable : internalEquation->mAllVariables) { + if (variable->mType == AnalyserInternalVariable::Type::UNKNOWN) { + variable->mType = AnalyserInternalVariable::Type::UNDERCONSTRAINED; } } + } + } + + // Add issues for any invalid variable. + + for (const auto &internalVariable : mInternalVariables) { + switch (internalVariable->mType) { + case AnalyserInternalVariable::Type::UNKNOWN: + addInvalidVariableIssue(internalVariable, + Issue::ReferenceRule::ANALYSER_VARIABLE_UNUSED); + + break; + case AnalyserInternalVariable::Type::SHOULD_BE_STATE: + addInvalidVariableIssue(internalVariable, + Issue::ReferenceRule::ANALYSER_STATE_NOT_INITIALISED); break; - default: // Other types we don't care about. + case AnalyserInternalVariable::Type::UNDERCONSTRAINED: + addInvalidVariableIssue(internalVariable, + Issue::ReferenceRule::ANALYSER_VARIABLE_UNDERCONSTRAINED); + + break; + case AnalyserInternalVariable::Type::OVERCONSTRAINED: + addInvalidVariableIssue(internalVariable, + Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED); + + break; + default: + // Any other type has already been handled elsewhere. + break; } } + // If we have some errors, then our model is invalid. + if (mAnalyser->errorCount() != 0) { - if (!underconstrainedVariables.empty()) { - if (!overconstrainedVariables.empty()) { + const auto hasUnderconstrainedVariables = std::any_of(mInternalVariables.begin(), mInternalVariables.end(), [](const auto &iv) { + switch (iv->mType) { + case AnalyserInternalVariable::Type::UNKNOWN: + case AnalyserInternalVariable::Type::SHOULD_BE_STATE: + case AnalyserInternalVariable::Type::UNDERCONSTRAINED: + return true; + default: + return false; + } + }); + const auto hasOverconstrainedVariables = std::any_of(mInternalVariables.begin(), mInternalVariables.end(), [](const auto &iv) { + return iv->mType == AnalyserInternalVariable::Type::OVERCONSTRAINED; + }); + + if (hasUnderconstrainedVariables) { + if (hasOverconstrainedVariables) { mAnalyserModel->mPimpl->mType = AnalyserModel::Type::UNSUITABLY_CONSTRAINED; } else { mAnalyserModel->mPimpl->mType = AnalyserModel::Type::UNDERCONSTRAINED; @@ -2830,10 +2725,9 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Determine the type of our model. - auto hasNlaEquations = std::any_of(mInternalEquations.begin(), mInternalEquations.end(), [=](const auto &ie) { + auto hasNlaEquations = std::any_of(mInternalEquations.begin(), mInternalEquations.end(), [&](const auto &ie) { if (ie->mType == AnalyserInternalEquation::Type::NLA) { - // Make sure that not all the variables involved in the NLA system - // have been marked as external + // Make sure that not all the variables involved in the NLA system have been marked as external. return std::any_of(ie->mUnknownVariables.begin(), ie->mUnknownVariables.end(), [](const auto &uv) { return !uv->mIsExternalVariable; @@ -2857,24 +2751,28 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) return; } - // Add a dummy equation for each of our true constants. - // Note: this is so that a constant can be marked as an external variable. + // Add a dummy equation for constants and for external variables that have no equation. + // Note: for constants, this is so that they can be marked as external variables. for (const auto &internalVariable : mInternalVariables) { - if (internalVariable->mType == AnalyserInternalVariable::Type::CONSTANT) { + const auto isConstant = internalVariable->mType == AnalyserInternalVariable::Type::CONSTANT; + auto isExternalWithNoEquation = !isConstant && internalVariable->mIsExternalVariable + && std::none_of(mInternalEquations.begin(), mInternalEquations.end(), [&internalVariable](const auto &ie) { + return std::find(ie->mUnknownVariables.begin(), ie->mUnknownVariables.end(), internalVariable) != ie->mUnknownVariables.end(); + }); + + if (isConstant || isExternalWithNoEquation) { mInternalEquations.push_back(AnalyserInternalEquation::create(internalVariable)); } } - // Make it known through our API whether the model has some external - // variables. + // Make it known through our API whether the model has some external variables. mAnalyserModel->mPimpl->mHasExternalVariables = hasExternalVariables; - // Create a mapping between our internal equations and our future equations - // in the API. + // Create a mapping between our internal equations and our future equations in the API. - std::map aie2aeMappings; + std::unordered_map aie2aeMappings; for (const auto &internalEquation : mInternalEquations) { aie2aeMappings.emplace(internalEquation, AnalyserEquation::AnalyserEquationImpl::create()); @@ -2884,7 +2782,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Note: start because we need to determine the type of our equations before we can make our internal variables // available through our API. - std::map aie2aetMappings; + std::unordered_map aie2aetMappings; for (const auto &internalEquation : mInternalEquations) { // Determine whether the equation is an external one. @@ -2937,8 +2835,8 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Make our internal variables available through our API. - std::map aiv2avMappings; - std::map v2avMappings; + std::unordered_map aiv2avMappings; + std::unordered_map v2avMappings; auto stateIndex = MAX_SIZE_T; auto constantIndex = MAX_SIZE_T; auto computedConstantIndex = MAX_SIZE_T; @@ -2968,7 +2866,6 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) break; case AnalyserInternalVariable::Type::ALGEBRAIC_VARIABLE: - case AnalyserInternalVariable::Type::INITIALISED_ALGEBRAIC_VARIABLE: variableType = AnalyserVariable::Type::ALGEBRAIC_VARIABLE; break; @@ -2982,25 +2879,13 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Retrieve the equations used to compute the variable. AnalyserEquationPtrs equations; - auto isNlaEquation = false; for (const auto &internalEquation : mInternalEquations) { - if (std::find(internalEquation->mUnknownVariables.begin(), internalEquation->mUnknownVariables.end(), internalVariable) != internalEquation->mUnknownVariables.end()) { + if (containsInternalVariable(internalEquation->mUnknownVariables, internalVariable)) { equations.push_back(aie2aeMappings[internalEquation]); - - if ((aie2aetMappings.find(internalEquation) != aie2aetMappings.end()) - && (aie2aetMappings[internalEquation] == AnalyserEquation::Type::NLA)) { - isNlaEquation = true; - } } } - // Correct the type of the variable if it is a computed constant that is computed using an NLA equation. - - if ((variableType == AnalyserVariable::Type::COMPUTED_CONSTANT) && isNlaEquation) { - variableType = AnalyserVariable::Type::ALGEBRAIC_VARIABLE; - } - // Populate and keep track of the state/variable. auto variable = AnalyserVariable::AnalyserVariableImpl::create(); @@ -3041,7 +2926,9 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) for (const auto &internalEquation : mInternalEquations) { // Make sure that the type of the equation is known. - if (aie2aetMappings.find(internalEquation) == aie2aetMappings.end()) { + auto aetIt = aie2aetMappings.find(internalEquation); + + if (aetIt == aie2aetMappings.end()) { continue; } @@ -3053,30 +2940,19 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Manipulate the equation, if needed. - auto equationType = aie2aetMappings[internalEquation]; + auto equationType = aetIt->second; - switch (equationType) { - case AnalyserEquation::Type::NLA: - // The equation is currently of the form LHS = RHS, but we want it - // in the form LHS-RHS, so replace the equality element with a minus - // one. + if (equationType == AnalyserEquation::Type::NLA) { + // The equation is currently of the form LHS = RHS, but we want it in the form LHS-RHS, so replace the + // equality element with a minus one. internalEquation->mAst->setType(AnalyserEquationAst::Type::MINUS); - break; - case AnalyserEquation::Type::EXTERNAL: - // Do nothing. - - break; - default: - // Swap the LHS and RHS of the equation if its unknown variable is - // on its RHS. + // Now that the equation is in the form LHS-RHS, we can simplify it (e.g., in case either the LHS or the RHS + // is equal to zero, in which case we would end up with LHS-0 or 0-RHS, which can be simplified to LHS or + // -RHS, respectively). - if (internalEquation->variableOnRhs(internalEquation->mUnknownVariables.front())) { - internalEquation->mAst->swapLeftAndRightChildren(); - } - - break; + internalEquation->mAst = simplifyAst(internalEquation->mAst); } // Determine the equation's dependencies, i.e. the equations for the @@ -3085,26 +2961,39 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) VariablePtrs variableDependencies; if (equationType == AnalyserEquation::Type::EXTERNAL) { + variableDependencies.reserve(internalEquation->mUnknownVariables.size()); + for (const auto &unknownVariable : internalEquation->mUnknownVariables) { for (const auto &dependency : unknownVariable->mDependencies) { - variableDependencies.push_back(dependency); + variableDependencies.push_back(dependency->mVariable); } } } else { - variableDependencies = internalEquation->mDependencies; + const auto &ieUnknownVariables = internalEquation->mUnknownVariables; + + variableDependencies.reserve(internalEquation->mAllVariables.size()); + + for (const auto &equationVariable : internalEquation->mAllVariables) { + if (std::find(ieUnknownVariables.begin(), ieUnknownVariables.end(), equationVariable) != ieUnknownVariables.end()) { + continue; + } + + variableDependencies.push_back(equationVariable->mVariable); + } } AnalyserEquationPtrs equationDependencies; + std::unordered_set seenAnalyserEquations; for (const auto &variableDependency : variableDependencies) { auto analyserVariable = v2avMappings[variableDependency]; if (analyserVariable != nullptr) { for (const auto &analyserEquation : analyserVariable->analyserEquations()) { - if (std::find(equationDependencies.begin(), equationDependencies.end(), analyserEquation) == equationDependencies.end()) { + if (seenAnalyserEquations.insert(analyserEquation.get()).second) { if (analyserVariable->type() == AnalyserVariable::Type::CONSTANT) { - // This is a constant, so keep track of it in case it is untracked and in case we need to - // generate some code for it. + // This is a constant, so keep track of it in case it is untracked and we need to generate + // some code for it. analyserEquation->mPimpl->mConstant = analyserVariable; } @@ -3132,7 +3021,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) equation->mPimpl->mType = equationType; equation->mPimpl->mAst = (equationType == AnalyserEquation::Type::EXTERNAL) ? nullptr : - internalEquation->mAst; + simplifyAst(internalEquation->mAst); equation->mPimpl->mNlaSystemIndex = internalEquation->mNlaSystemIndex; for (const auto &unknownVariable : internalEquation->mUnknownVariables) { @@ -3173,7 +3062,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Note: obviously, this can only be done once all our equations are ready. for (const auto &analyserEquation : mAnalyserModel->mPimpl->mAnalyserEquations) { - AnalyserEquationPtrs checkedEquations; + std::unordered_set checkedEquations; analyserEquation->mPimpl->mIsStateRateBased = isStateRateBased(analyserEquation, checkedEquations); } @@ -3181,14 +3070,14 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) AnalyserExternalVariablePtrs::const_iterator Analyser::AnalyserImpl::findExternalVariable(const VariablePtr &variable) const { - return std::find_if(mExternalVariables.begin(), mExternalVariables.end(), [=](const auto &ev) { + return std::find_if(mExternalVariables.begin(), mExternalVariables.end(), [&](const auto &ev) { return ev->variable() == variable; }); } AnalyserExternalVariablePtrs::const_iterator Analyser::AnalyserImpl::findExternalVariable(const AnalyserExternalVariablePtr &externalVariable) const { - return std::find_if(mExternalVariables.begin(), mExternalVariables.end(), [=](const auto &ev) { + return std::find_if(mExternalVariables.begin(), mExternalVariables.end(), [&](const auto &ev) { return ev == externalVariable; }); } diff --git a/src/analyser_p.h b/src/analyser_p.h index 237e5c3b4a..f6627a792e 100644 --- a/src/analyser_p.h +++ b/src/analyser_p.h @@ -14,7 +14,10 @@ See the License for the specific language governing permissions and limitations under the License. */ -#include "libcellml/analyser.h" +#include +#include +#include + #include "libcellml/generatorprofile.h" #include "libcellml/issue.h" @@ -40,6 +43,22 @@ using AnalyserEquationPtrs = std::vector; using AnalyserVariablePtrs = std::vector; using AnalyserExternalVariablePtrs = std::vector; +using AnalyserEquationAstPtrs = std::vector; + +using SESymbol = SymEngine::RCP; +using SEExpression = SymEngine::RCP; +using SESymbol2AIVariableMap = std::map; +using AIVariable2SESymbolMap = std::map; + +struct OSInfo +{ + AnalyserEquationAstPtr ast; + SEExpression seDiffExpression; +}; + +using OSName2OSInfoMap = std::map; +using SEExpressionResult = std::tuple; + struct AnalyserInternalVariable { enum struct Type @@ -52,7 +71,6 @@ struct AnalyserInternalVariable CONSTANT, COMPUTED_TRUE_CONSTANT, COMPUTED_VARIABLE_BASED_CONSTANT, - INITIALISED_ALGEBRAIC_VARIABLE, ALGEBRAIC_VARIABLE, UNDERCONSTRAINED, OVERCONSTRAINED @@ -64,7 +82,11 @@ struct AnalyserInternalVariable VariablePtr mInitialisingVariable; VariablePtr mVariable; - VariablePtrs mDependencies; + + AnalyserInternalVariablePtrs mDependencies; + + AnalyserInternalEquationPtr mMatchedEquation; + AnalyserInternalEquationPtrs mUnmatchedEquations; static AnalyserInternalVariablePtr create(const VariablePtr &variable); @@ -90,7 +112,7 @@ struct AnalyserInternalEquation Type mType = Type::UNKNOWN; - VariablePtrs mDependencies; + AnalyserInternalVariablePtrs mDependencies; AnalyserEquationAstPtr mAst; @@ -101,35 +123,24 @@ struct AnalyserInternalEquation AnalyserInternalVariablePtrs mAllVariables; AnalyserInternalVariablePtrs mUnknownVariables; + SEExpression mSEExpression; + bool mHasBeenRearranged = false; + size_t mNlaSystemIndex = MAX_SIZE_T; AnalyserInternalEquationWeakPtrs mNlaSiblings; - bool mComputedTrueConstant = true; - bool mComputedVariableBasedConstant = true; - static AnalyserInternalEquationPtr create(const ComponentPtr &component); static AnalyserInternalEquationPtr create(const AnalyserInternalVariablePtr &variable); void addVariable(const AnalyserInternalVariablePtr &variable); void addStateVariable(const AnalyserInternalVariablePtr &stateVariable); + void addUnknownVariable(const AnalyserInternalVariablePtr &unknownVariable); - static bool isKnownVariable(const AnalyserInternalVariablePtr &variable); - static bool isKnownStateVariable(const AnalyserInternalVariablePtr &stateVariable); + bool isVariable(const AnalyserInternalVariablePtr &variable, const AnalyserEquationAstPtr &astChild); + bool containsVariable(const AnalyserInternalVariablePtr &variable, const AnalyserEquationAstPtr &astChild); + bool isVariableIsolated(const AnalyserInternalVariablePtr &variable); - static bool hasKnownVariables(const AnalyserInternalVariablePtrs &variables); - bool hasKnownVariables(); - - static bool isNonConstantVariable(const AnalyserInternalVariablePtr &variable); - - static bool hasNonConstantVariables(const AnalyserInternalVariablePtrs &variables); - bool hasNonConstantVariables(); - - bool variableOnLhsRhs(const AnalyserInternalVariablePtr &variable, - const AnalyserEquationAstPtr &astChild); - bool variableOnRhs(const AnalyserInternalVariablePtr &variable); - bool variableOnLhsOrRhs(const AnalyserInternalVariablePtr &variable); - - bool check(const AnalyserModelPtr &analyserModel, bool checkNlaSystems); + SEExpression rearrangeForSESymbol(const SESymbol &seSymbol); }; /** @@ -164,12 +175,20 @@ class Analyser::AnalyserImpl: public Logger::LoggerImpl std::unordered_map mInternalVariableMap; AnalyserInternalEquationPtrs mInternalEquations; + AIVariable2SESymbolMap mAIVariable2SESymbolMap; + SESymbol2AIVariableMap mSESymbol2AIVariableMap; + AnalyserInternalVariablePtrs mFirstVariables; + AnalyserInternalVariablePtrs mLastVariables; + GeneratorProfilePtr mGeneratorProfile = GeneratorProfile::create(); - std::map mStandardUnits; - std::map mCiCnUnits; + std::unordered_map mStandardUnits; + std::unordered_map mCiCnUnits; AnalyserImpl(); + ~AnalyserImpl(); + + void reset(); AnalyserInternalVariablePtr internalVariable(const VariablePtr &variable); @@ -183,10 +202,6 @@ class Analyser::AnalyserImpl: public Logger::LoggerImpl void analyseComponent(const ComponentPtr &component); void analyseComponentVariables(const ComponentPtr &component); - void equivalentVariables(const VariablePtr &variable, - VariablePtrs &equivalentVariables) const; - VariablePtrs equivalentVariables(const VariablePtr &variable) const; - void analyseEquationAst(const AnalyserEquationAstPtr &ast); void updateUnitsMapWithStandardUnit(const std::string &unitsName, @@ -253,11 +268,28 @@ class Analyser::AnalyserImpl: public Logger::LoggerImpl static bool isExternalVariable(const AnalyserInternalVariablePtr &variable); bool isStateRateBased(const AnalyserEquationPtr &analyserEquation, - AnalyserEquationPtrs &checkedEquations); + std::unordered_set &checkedEquations); void addInvalidVariableIssue(const AnalyserInternalVariablePtr &variable, Issue::ReferenceRule referenceRule); + SEExpressionResult astToSymEngine(const AnalyserEquationAstPtr &ast, + OSName2OSInfoMap *osName2osInfoMap = nullptr); + + AnalyserEquationAstPtr simplifyAst(const AnalyserEquationAstPtr &ast); + AnalyserEquationAstPtr symEngineToAst(const SEExpression &seExpression, + const AnalyserEquationAstPtr &parentAst = nullptr, + const OSName2OSInfoMap *osName2osInfoMap = nullptr); + + void replaceAstTree(const AnalyserInternalEquationPtr &equation, const AnalyserEquationAstPtr &newAst); + void updateEquationFromSEExpression(const AnalyserInternalEquationPtr &equation, const SEExpression &seExpression); + + void makeVariableKnown(const AnalyserInternalVariablePtr &variable, const AnalyserInternalEquationPtr &equation); + bool matchVariableAndEquation(const AnalyserInternalVariablePtr &variable, const AnalyserInternalEquationPtr &equation); + void matchVariablesAndEquations(AnalyserInternalVariablePtrs &variables, AnalyserInternalEquationPtrs &equations); + void substituteVariablesInEquations(); + void classifyVariablesAndEquations(); + void analyseModel(const ModelPtr &model); AnalyserExternalVariablePtrs::const_iterator findExternalVariable(const VariablePtr &variable) const; diff --git a/src/analyserequation.cpp b/src/analyserequation.cpp index 50959cd409..d9a352bd0d 100644 --- a/src/analyserequation.cpp +++ b/src/analyserequation.cpp @@ -149,7 +149,7 @@ size_t AnalyserEquation::stateCount() const return mPimpl->mStates.size(); } -std::vector AnalyserEquation::states() const +const std::vector &AnalyserEquation::states() const { return mPimpl->mStates; } @@ -168,7 +168,7 @@ size_t AnalyserEquation::computedConstantCount() const return mPimpl->mComputedConstants.size(); } -std::vector AnalyserEquation::computedConstants() const +const std::vector &AnalyserEquation::computedConstants() const { return mPimpl->mComputedConstants; } @@ -187,7 +187,7 @@ size_t AnalyserEquation::algebraicVariableCount() const return mPimpl->mAlgebraicVariables.size(); } -std::vector AnalyserEquation::algebraicVariables() const +const std::vector &AnalyserEquation::algebraicVariables() const { return mPimpl->mAlgebraicVariables; } @@ -206,7 +206,7 @@ size_t AnalyserEquation::externalVariableCount() const return mPimpl->mExternalVariables.size(); } -std::vector AnalyserEquation::externalVariables() const +const std::vector &AnalyserEquation::externalVariables() const { return mPimpl->mExternalVariables; } diff --git a/src/analyserequationast.cpp b/src/analyserequationast.cpp index f543f766f1..e12c4847ea 100644 --- a/src/analyserequationast.cpp +++ b/src/analyserequationast.cpp @@ -170,7 +170,7 @@ void AnalyserEquationAst::setType(Type type) mPimpl->mType = type; } -std::string AnalyserEquationAst::value() const +const std::string &AnalyserEquationAst::value() const { return mPimpl->mValue; } @@ -230,6 +230,26 @@ void AnalyserEquationAst::setRightChild(const AnalyserEquationAstPtr &rightChild mPimpl->mRightChild = rightChild; } +AnalyserEquationAstPtr AnalyserEquationAst::clone(const AnalyserEquationAstPtr &parentAst) const +{ + auto res = AnalyserEquationAst::create(); + + res->setType(type()); + res->setValue(value()); + res->setVariable(variable()); + res->setParent(parentAst); + + if (leftChild() != nullptr) { + res->setLeftChild(leftChild()->clone(res)); + } + + if (rightChild() != nullptr) { + res->setRightChild(rightChild()->clone(res)); + } + + return res; +} + void AnalyserEquationAst::swapLeftAndRightChildren() { auto oldOwnedLeftChild = mPimpl->mOwnedLeftChild; diff --git a/src/analyserexternalvariable.cpp b/src/analyserexternalvariable.cpp index 41a9606ff9..67ef5bdf1f 100644 --- a/src/analyserexternalvariable.cpp +++ b/src/analyserexternalvariable.cpp @@ -31,7 +31,7 @@ std::vector::iterator AnalyserExternalVariable::AnalyserExternalVar const std::string &componentName, const std::string &variableName) { - return std::find_if(mDependencies.begin(), mDependencies.end(), [=](const auto &v) { + return std::find_if(mDependencies.begin(), mDependencies.end(), [&](const auto &v) { return (owningModel(v) == model) && (owningComponent(v)->name() == componentName) && (v->name() == variableName); @@ -40,7 +40,7 @@ std::vector::iterator AnalyserExternalVariable::AnalyserExternalVar std::vector::iterator AnalyserExternalVariable::AnalyserExternalVariableImpl::findDependency(const VariablePtr &variable) { - return std::find_if(mDependencies.begin(), mDependencies.end(), [=](const auto &v) { + return std::find_if(mDependencies.begin(), mDependencies.end(), [&](const auto &v) { return v == variable; }); } @@ -155,7 +155,7 @@ VariablePtr AnalyserExternalVariable::dependency(const ModelPtr &model, nullptr; } -std::vector AnalyserExternalVariable::dependencies() const +const std::vector &AnalyserExternalVariable::dependencies() const { return mPimpl->mDependencies; } diff --git a/src/analysermodel.cpp b/src/analysermodel.cpp index 9e86c66c4f..7eb8656d5f 100644 --- a/src/analysermodel.cpp +++ b/src/analysermodel.cpp @@ -157,10 +157,12 @@ size_t AnalyserModel::stateCount() const return mPimpl->mStates.size(); } -std::vector AnalyserModel::states() const +const std::vector &AnalyserModel::states() const { + static const std::vector NO_ANALYSER_VARIABLE; + if (!isValid()) { - return {}; + return NO_ANALYSER_VARIABLE; } return mPimpl->mStates; @@ -185,10 +187,12 @@ size_t AnalyserModel::constantCount() const return mPimpl->mConstants.size(); } -std::vector AnalyserModel::constants() const +const std::vector &AnalyserModel::constants() const { + static const std::vector NO_ANALYSER_VARIABLE; + if (!isValid()) { - return {}; + return NO_ANALYSER_VARIABLE; } return mPimpl->mConstants; @@ -212,10 +216,12 @@ size_t AnalyserModel::computedConstantCount() const return mPimpl->mComputedConstants.size(); } -std::vector AnalyserModel::computedConstants() const +const std::vector &AnalyserModel::computedConstants() const { + static const std::vector NO_ANALYSER_VARIABLE; + if (!isValid()) { - return {}; + return NO_ANALYSER_VARIABLE; } return mPimpl->mComputedConstants; @@ -239,10 +245,12 @@ size_t AnalyserModel::algebraicVariableCount() const return mPimpl->mAlgebraicVariables.size(); } -std::vector AnalyserModel::algebraicVariables() const +const std::vector &AnalyserModel::algebraicVariables() const { + static const std::vector NO_ANALYSER_VARIABLE; + if (!isValid()) { - return {}; + return NO_ANALYSER_VARIABLE; } return mPimpl->mAlgebraicVariables; @@ -266,10 +274,12 @@ size_t AnalyserModel::externalVariableCount() const return mPimpl->mExternalVariables.size(); } -std::vector AnalyserModel::externalVariables() const +const std::vector &AnalyserModel::externalVariables() const { + static const std::vector NO_ANALYSER_VARIABLE; + if (!isValid()) { - return {}; + return NO_ANALYSER_VARIABLE; } return mPimpl->mExternalVariables; @@ -336,10 +346,12 @@ size_t AnalyserModel::analyserEquationCount() const return mPimpl->mAnalyserEquations.size(); } -std::vector AnalyserModel::analyserEquations() const +const std::vector &AnalyserModel::analyserEquations() const { + static const std::vector NO_ANALYSER_EQUATION; + if (!isValid()) { - return {}; + return NO_ANALYSER_EQUATION; } return mPimpl->mAnalyserEquations; diff --git a/src/analysersymengine.cpp b/src/analysersymengine.cpp new file mode 100644 index 0000000000..1f7ff4d5d9 --- /dev/null +++ b/src/analysersymengine.cpp @@ -0,0 +1,2471 @@ +/* +Copyright libCellML Contributors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include "analyser_p.h" +#include "analyserequationast_p.h" + +namespace libcellml { + +bool containsSymEngineByPredicate(const SEExpression &seExpression, const auto &predicate) +{ + if (predicate(seExpression)) { + return true; + } + + for (const auto &arg : seExpression->get_args()) { + if (containsSymEngineByPredicate(arg, predicate)) { + return true; + } + } + + return false; +} + +SEExpression simplifySEExpression(const SEExpression &seExpression) +{ + if (seExpression->get_type_code() == SymEngine::SYMENGINE_EQUALITY) { + auto args = seExpression->get_args(); + + return SymEngine::simplify(SymEngine::Eq(args.front(), SymEngine::expand(args.back()))); + } + + auto simplifiedArgs = [&](const SEExpression &seExpression) { + SymEngine::vec_basic args; + + args.reserve(seExpression->get_args().size()); + + for (const auto &arg : seExpression->get_args()) { + args.push_back(simplifySEExpression(arg)); + } + + return args; + }; + + if (seExpression->get_type_code() == SymEngine::SYMENGINE_CONSTANT) { + return seExpression; + } + + if (seExpression->get_type_code() == SymEngine::SYMENGINE_ADD) { + return SymEngine::simplify(SymEngine::expand(SymEngine::add(simplifiedArgs(seExpression)))); + } + + if (seExpression->get_type_code() == SymEngine::SYMENGINE_MUL) { + return SymEngine::simplify(SymEngine::expand(SymEngine::mul(simplifiedArgs(seExpression)))); + } + + if (seExpression->get_type_code() == SymEngine::SYMENGINE_POW) { + auto args = simplifiedArgs(seExpression); + + return SymEngine::simplify(SymEngine::pow(args.front(), args.back())); + } + + return SymEngine::simplify(seExpression); +} + +SEExpression AnalyserInternalEquation::rearrangeForSESymbol(const SESymbol &seSymbol) +{ + auto isSEExpressionComplex = [&](const auto &self, const SEExpression &seExpression) -> bool { + if (SymEngine::is_a_Complex(*seExpression)) { + return true; + } + + for (const auto &arg : seExpression->get_args()) { + if (self(self, arg)) { + return true; + } + } + + return false; + }; + + auto containsSESymbol = [&](const SEExpression &seExpression) -> bool { + auto predicate = [&](const SEExpression &candidate) { + return (candidate->get_type_code() == SymEngine::SYMENGINE_SYMBOL) + && (SymEngine::rcp_static_cast(candidate)->get_name() == seSymbol->get_name()); + }; + + return containsSymEngineByPredicate(seExpression, predicate); + }; + + auto containsAnySESymbol = [&](const SEExpression &seExpression) -> bool { + auto predicate = [](const SEExpression &candidate) { + return candidate->get_type_code() == SymEngine::SYMENGINE_SYMBOL; + }; + + return containsSymEngineByPredicate(seExpression, predicate); + }; + + auto filterSolutions = [&](SymEngine::vec_basic solutions) { + solutions.erase(std::remove_if(solutions.begin(), solutions.end(), + [&](const SEExpression &solution) { + return isSEExpressionComplex(isSEExpressionComplex, solution) + || containsSESymbol(solution); + }), + solutions.end()); + + return solutions; + }; + + auto containsSEExp = [&](const SEExpression &seExpression) -> bool { + auto predicate = [&](const SEExpression &candidate) { + if (candidate->get_type_code() != SymEngine::SYMENGINE_POW) { + return false; + } + + auto args = candidate->get_args(); + + return SymEngine::eq(*args.front(), *SymEngine::E); + }; + + return containsSymEngineByPredicate(seExpression, predicate); + }; + + auto containsSELog = [&](const SEExpression &seExpression) -> bool { + auto predicate = [&](const SEExpression &candidate) { + return candidate->get_type_code() == SymEngine::SYMENGINE_LOG; + }; + + return containsSymEngineByPredicate(seExpression, predicate); + }; + + auto invertSimpleOddPower = [&](const SEExpression &seExpression) -> SEExpression { + auto equalityArgs = seExpression->get_args(); + + for (size_t i = 0; i < 2; ++i) { + auto powerSide = equalityArgs[i]; + auto otherSide = equalityArgs[1 - i]; + + if (powerSide->get_type_code() != SymEngine::SYMENGINE_POW) { + continue; + } + + auto powerArgs = powerSide->get_args(); + + if ((powerArgs.front()->get_type_code() != SymEngine::SYMENGINE_SYMBOL) + || (powerArgs.back()->get_type_code() != SymEngine::SYMENGINE_INTEGER)) { + continue; + } + + auto baseSymbol = SymEngine::rcp_static_cast(powerArgs.front()); + auto exponent = SymEngine::rcp_static_cast(powerArgs.back())->as_int(); + + if ((baseSymbol->get_name() == seSymbol->get_name()) && (exponent > 0)) { + return SymEngine::pow(otherSide, SymEngine::div(SymEngine::integer(1), SymEngine::integer(exponent))); + } + } + + return SymEngine::null; + }; + + // Solve the equation for the given variable. + + SymEngine::RCP solutionSet; + + try { + solutionSet = SymEngine::solve(mSEExpression, seSymbol); + } catch (const std::exception &) { + // SymEngine failed to solve the equation. This is likely because the variable we are trying to rearrange for is + // nested within a function that SymEngine cannot invert (e.g., sin(), log()), or because the equation is not a + // polynomial that SymEngine can handle. + + return SymEngine::null; + } + + // Filter the solutions to remove any that are complex or that contain the variable we are trying to rearrange for. + + auto solutions = filterSolutions(solutionSet->get_args()); + + // If there isn't exactly one solution left, we cannot be sure which one to return, so return null. + + if (solutions.size() != 1) { + return SymEngine::null; + } + + auto exactSolution = solutions.front(); + + // If the exact solution is fully numeric, convert it to a number node. + + if (!containsAnySESymbol(exactSolution)) { + return SymEngine::number(SymEngine::eval_double(*exactSolution)); + } + + // The solution is symbolic or could not be reduced to a number, so return the exact solution, but first try to + // simplify exponentials and logarithms, if there are any. + + auto simplifiedSolution = exactSolution; + + if (containsSEExp(exactSolution) || containsSELog(exactSolution)) { + simplifiedSolution = simplifySEExpression(exactSolution); + } + + // Try to do a simple odd-power inversion, if possible. + + auto oddPowerInversion = invertSimpleOddPower(mSEExpression); + + return oddPowerInversion.is_null() ? simplifiedSolution : oddPowerInversion; +} + +SEExpressionResult Analyser::AnalyserImpl::astToSymEngine(const AnalyserEquationAstPtr &ast, + OSName2OSInfoMap *osName2osInfoMap) +{ + // Make sure that we have an AST to convert. + + if (ast == nullptr) { + return {true, SymEngine::null}; + } + + // If an opaque symbol to AST map is provided and the node type is not natively supported by SymEngine, then we + // substitute the entire subtree with a fresh opaque symbol so that SymEngine can still manipulate the enclosing + // expression algebraically. + + auto opaqueSymbol = [&]() -> SEExpressionResult { + auto name = "__opaque_symbol_" + std::to_string(osName2osInfoMap->size()); + + osName2osInfoMap->emplace(name, OSInfo {ast, SymEngine::null}); + + return {true, SymEngine::symbol(name)}; + }; + + // Types that SymEngine cannot represent natively are substituted with a fresh opaque symbol before we attempt to + // recurse into their children, so that the children themselves are not converted unnecessarily. + + if (osName2osInfoMap != nullptr) { + auto astType = ast->type(); + + if (astType == AnalyserEquationAst::Type::DIFF) { + // Create a predictably named opaque symbol using the state variable's SymEngine symbol name so that + // matchVariableAndEquation() can construct the name directly, without searching the map. + + auto rightAst = ast->rightChild(); + [[maybe_unused]] auto [rightSuccess, right] = astToSymEngine(rightAst, nullptr); + [[maybe_unused]] auto [leftSuccess, left] = astToSymEngine(ast->leftChild(), nullptr); + auto name = "__diff_" + SymEngine::rcp_dynamic_cast(right)->get_name(); + + osName2osInfoMap->emplace(name, OSInfo {ast, SymEngine::function_symbol("diff", {left, right})}); + + return {true, SymEngine::symbol(name)}; + } + + if (astType == AnalyserEquationAst::Type::PIECEWISE) { + return opaqueSymbol(); + } + } + + // Recursively convert the left and right children. + + auto leftAst = ast->leftChild(); + auto rightAst = ast->rightChild(); + + auto [leftSuccess, left] = astToSymEngine(leftAst, osName2osInfoMap); + auto [rightSuccess, right] = astToSymEngine(rightAst, osName2osInfoMap); + + if (!leftSuccess || !rightSuccess) { + if (osName2osInfoMap != nullptr) { + return opaqueSymbol(); + } + + return {false, SymEngine::null}; + } + + // Check the AST's type and return its SymEngine equivalent. + + auto astType = ast->type(); + + switch (astType) { + // Equality. + + case AnalyserEquationAst::Type::EQUALITY: + return {true, SymEngine::Eq(left, right)}; + + // Relational and logical operators. + + case AnalyserEquationAst::Type::EQ: + return {true, SymEngine::Eq(left, right)}; + case AnalyserEquationAst::Type::NEQ: + return {true, SymEngine::Ne(left, right)}; + case AnalyserEquationAst::Type::LT: + return {true, SymEngine::Lt(left, right)}; + case AnalyserEquationAst::Type::LEQ: + return {true, SymEngine::Le(left, right)}; + case AnalyserEquationAst::Type::GT: + return {true, SymEngine::Gt(left, right)}; + case AnalyserEquationAst::Type::GEQ: + return {true, SymEngine::Ge(left, right)}; + case AnalyserEquationAst::Type::AND: + case AnalyserEquationAst::Type::OR: + case AnalyserEquationAst::Type::XOR: { + if (!SymEngine::is_a_Boolean(*left) || !SymEngine::is_a_Boolean(*right)) { + return {false, SymEngine::null}; + } + + auto leftBoolean = SymEngine::rcp_dynamic_cast(left); + auto rightBoolean = SymEngine::rcp_dynamic_cast(right); + + if (astType == AnalyserEquationAst::Type::AND) { + return {true, SymEngine::logical_and(SymEngine::set_boolean({leftBoolean, rightBoolean}))}; + } + + if (astType == AnalyserEquationAst::Type::OR) { + return {true, SymEngine::logical_or(SymEngine::set_boolean({leftBoolean, rightBoolean}))}; + } + + return {true, SymEngine::logical_xor(SymEngine::vec_boolean({leftBoolean, rightBoolean}))}; + } + case AnalyserEquationAst::Type::NOT: { + if (!SymEngine::is_a_Boolean(*left)) { + return {false, SymEngine::null}; + } + + return {true, SymEngine::logical_not(SymEngine::rcp_dynamic_cast(left))}; + } + + // Arithmetic operators. + + case AnalyserEquationAst::Type::PLUS: + if (!right.is_null()) { + return {true, SymEngine::add(left, right)}; + } + + return {true, left}; + case AnalyserEquationAst::Type::MINUS: + if (!right.is_null()) { + return {true, SymEngine::sub(left, right)}; + } + + return {true, SymEngine::mul(SymEngine::integer(-1), left)}; + case AnalyserEquationAst::Type::TIMES: + return {true, SymEngine::mul(left, right)}; + case AnalyserEquationAst::Type::DIVIDE: + return {true, SymEngine::div(left, right)}; + case AnalyserEquationAst::Type::POWER: + return {true, SymEngine::pow(left, right)}; + case AnalyserEquationAst::Type::ROOT: + if (!right.is_null()) { + return {true, SymEngine::pow(right, SymEngine::div(SymEngine::integer(1), left))}; + } + + return {true, SymEngine::pow(left, SymEngine::div(SymEngine::integer(1), SymEngine::integer(2)))}; + case AnalyserEquationAst::Type::ABS: + return {true, SymEngine::abs(left)}; + case AnalyserEquationAst::Type::EXP: + return {true, SymEngine::exp(left)}; + case AnalyserEquationAst::Type::LN: + return {true, SymEngine::log(left)}; + case AnalyserEquationAst::Type::LOG: + if (!right.is_null()) { + return {true, SymEngine::div(SymEngine::log(right), SymEngine::log(left))}; + } + + return {true, SymEngine::div(SymEngine::log(left), SymEngine::log(SymEngine::integer(10)))}; + case AnalyserEquationAst::Type::CEILING: + return {true, SymEngine::ceiling(left)}; + case AnalyserEquationAst::Type::FLOOR: + return {true, SymEngine::floor(left)}; + case AnalyserEquationAst::Type::MIN: + return {true, SymEngine::min({left, right})}; + case AnalyserEquationAst::Type::MAX: + return {true, SymEngine::max({left, right})}; + case AnalyserEquationAst::Type::REM: + return {true, SymEngine::function_symbol("mod", {left, right})}; + + // Calculus elements. + + case AnalyserEquationAst::Type::DIFF: + return {true, SymEngine::function_symbol("diff", {left, right})}; + + // Trigonometric operators. + + case AnalyserEquationAst::Type::SIN: + return {true, SymEngine::sin(left)}; + case AnalyserEquationAst::Type::COS: + return {true, SymEngine::cos(left)}; + case AnalyserEquationAst::Type::TAN: + return {true, SymEngine::tan(left)}; + case AnalyserEquationAst::Type::SEC: + return {true, SymEngine::sec(left)}; + case AnalyserEquationAst::Type::CSC: + return {true, SymEngine::csc(left)}; + case AnalyserEquationAst::Type::COT: + return {true, SymEngine::cot(left)}; + case AnalyserEquationAst::Type::SINH: + return {true, SymEngine::sinh(left)}; + case AnalyserEquationAst::Type::COSH: + return {true, SymEngine::cosh(left)}; + case AnalyserEquationAst::Type::TANH: + return {true, SymEngine::tanh(left)}; + case AnalyserEquationAst::Type::SECH: + return {true, SymEngine::sech(left)}; + case AnalyserEquationAst::Type::CSCH: + return {true, SymEngine::csch(left)}; + case AnalyserEquationAst::Type::COTH: + return {true, SymEngine::coth(left)}; + case AnalyserEquationAst::Type::ASIN: + return {true, SymEngine::asin(left)}; + case AnalyserEquationAst::Type::ACOS: + return {true, SymEngine::acos(left)}; + case AnalyserEquationAst::Type::ATAN: + return {true, SymEngine::atan(left)}; + case AnalyserEquationAst::Type::ASEC: + return {true, SymEngine::asec(left)}; + case AnalyserEquationAst::Type::ACSC: + return {true, SymEngine::acsc(left)}; + case AnalyserEquationAst::Type::ACOT: + return {true, SymEngine::acot(left)}; + case AnalyserEquationAst::Type::ASINH: + return {true, SymEngine::asinh(left)}; + case AnalyserEquationAst::Type::ACOSH: + return {true, SymEngine::acosh(left)}; + case AnalyserEquationAst::Type::ATANH: + return {true, SymEngine::atanh(left)}; + case AnalyserEquationAst::Type::ASECH: + return {true, SymEngine::asech(left)}; + case AnalyserEquationAst::Type::ACSCH: + return {true, SymEngine::acsch(left)}; + case AnalyserEquationAst::Type::ACOTH: + return {true, SymEngine::acoth(left)}; + + // Token elements. + + case AnalyserEquationAst::Type::CI: { + auto aiVariable = internalVariable(ast->variable()); + + if (mAIVariable2SESymbolMap.find(aiVariable) == mAIVariable2SESymbolMap.end()) { + // We haven't yet created a SymEngine symbol for this internal variable, so create one (making sure that its + // name is unique) and add it to mAIVariable2SESymbolMap and mSESymbol2AIVariableMap. + + auto variableName = aiVariable->mVariable->name(); + auto uniqueSeVariable = SymEngine::symbol(variableName); + auto uniqueVariableNameIndex = MAX_SIZE_T; + + while (mSESymbol2AIVariableMap.find(uniqueSeVariable) != mSESymbol2AIVariableMap.end()) { + uniqueSeVariable = SymEngine::symbol(variableName + "_" + convertToString(++uniqueVariableNameIndex)); + } + + auto seVariable = std::move(uniqueSeVariable); + + mAIVariable2SESymbolMap[aiVariable] = seVariable; + mSESymbol2AIVariableMap[seVariable] = aiVariable; + } + + return {true, mAIVariable2SESymbolMap.at(aiVariable)}; + } + case AnalyserEquationAst::Type::CN: { + // Whole CN values should be converted to integers, so that SymEngine can simplify them properly. + + auto cnValue = std::stod(ast->value()); + auto roundedCnValue = std::llround(cnValue); + + if (areNearlyEqual(cnValue, static_cast(roundedCnValue))) { + return {true, SymEngine::integer(roundedCnValue)}; + } + + return {true, SymEngine::number(cnValue)}; + } + + // Qualifier elements. + + case AnalyserEquationAst::Type::DEGREE: + case AnalyserEquationAst::Type::LOGBASE: + case AnalyserEquationAst::Type::BVAR: + return {true, left}; + + // Constants. + + case AnalyserEquationAst::Type::TRUE: + return {true, SymEngine::number(1.0)}; + case AnalyserEquationAst::Type::FALSE: + return {true, SymEngine::number(0.0)}; + case AnalyserEquationAst::Type::E: + return {true, SymEngine::E}; + case AnalyserEquationAst::Type::PI: + return {true, SymEngine::pi}; + case AnalyserEquationAst::Type::INF: + return {true, SymEngine::Inf}; + default: + // Conversion is not possible with this type. So, substitute the entire subtree with a fresh opaque symbol if an + // opaque symbol to AST map is provided. + + if (osName2osInfoMap != nullptr) { + return opaqueSymbol(); + } + + return {false, SymEngine::null}; + } +} + +AnalyserEquationAstPtr Analyser::AnalyserImpl::simplifyAst(const AnalyserEquationAstPtr &ast) +{ + auto cnValue = [](const AnalyserEquationAstPtr &ast, double &value) -> bool { + if ((ast == nullptr) || (ast->type() != AnalyserEquationAst::Type::CN)) { + return false; + } + + value = std::stod(ast->value()); + + return true; + }; + + auto isCnValue = [&cnValue](const AnalyserEquationAstPtr &ast, double value) { + double astValue; + + if (!cnValue(ast, astValue)) { + return false; + } + + return areNearlyEqual(astValue, value); + }; + + auto makeUnaryMinus = [&](const AnalyserEquationAstPtr &child, const AnalyserEquationAstPtr &parentAst) { + auto res = AnalyserEquationAst::create(); + + res->setType(AnalyserEquationAst::Type::MINUS); + res->setParent(parentAst); + res->setLeftChild(child); + + child->setParent(res); + + return simplifyAst(res); + }; + + auto makeCnNode = [](double value, const AnalyserEquationAstPtr &parentAst) { + auto res = AnalyserEquationAst::create(); + + res->setType(AnalyserEquationAst::Type::CN); + res->setValue(convertToString(value)); + res->setParent(parentAst); + + return res; + }; + + // Recursively simplify the given AST's children first. + + if (ast == nullptr) { + return ast; + } + + auto leftAst = simplifyAst(ast->leftChild()); + auto rightAst = simplifyAst(ast->rightChild()); + + if (leftAst != ast->leftChild()) { + ast->setLeftChild(leftAst); + } + + if (rightAst != ast->rightChild()) { + ast->setRightChild(rightAst); + } + + if (leftAst != nullptr) { + leftAst->setParent(ast); + } + + auto rightExists = rightAst != nullptr; + + if (rightExists) { + rightAst->setParent(ast); + } + + // Attempt to simplify the given AST based on its type and the types and values of its children. + + double leftValue; + auto leftIsConstant = false; + auto leftIsZero = false; + auto leftIsOne = false; + auto leftIsNegOne = false; + + if (cnValue(leftAst, leftValue)) { + leftIsConstant = true; + leftIsZero = areNearlyEqual(leftValue, 0.0); + leftIsOne = areNearlyEqual(leftValue, 1.0); + leftIsNegOne = areNearlyEqual(leftValue, -1.0); + } + + double rightValue; + auto rightIsConstant = false; + auto rightIsZero = false; + auto rightIsOne = false; + auto rightIsNegOne = false; + + if (cnValue(rightAst, rightValue)) { + rightIsConstant = true; + rightIsZero = areNearlyEqual(rightValue, 0.0); + rightIsOne = areNearlyEqual(rightValue, 1.0); + rightIsNegOne = areNearlyEqual(rightValue, -1.0); + } + + switch (ast->type()) { + // Relational and logical operators. + + case AnalyserEquationAst::Type::EQ: + // a == b -> 1.0 or 0.0 (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode(areNearlyEqual(leftValue, rightValue) ? 1.0 : 0.0, ast->parent()); + } + + break; + case AnalyserEquationAst::Type::NEQ: + // a != b -> 1.0 or 0.0 (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode(!areNearlyEqual(leftValue, rightValue) ? 1.0 : 0.0, ast->parent()); + } + + break; + case AnalyserEquationAst::Type::LT: + // a < b -> 1.0 or 0.0 (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode((leftValue < rightValue) ? 1.0 : 0.0, ast->parent()); + } + + break; + case AnalyserEquationAst::Type::LEQ: + // a <= b -> 1.0 or 0.0 (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode((leftValue <= rightValue) ? 1.0 : 0.0, ast->parent()); + } + + break; + case AnalyserEquationAst::Type::GT: + // a > b -> 1.0 or 0.0 (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode((leftValue > rightValue) ? 1.0 : 0.0, ast->parent()); + } + + break; + case AnalyserEquationAst::Type::GEQ: + // a >= b -> 1.0 or 0.0 (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode((leftValue >= rightValue) ? 1.0 : 0.0, ast->parent()); + } + + break; + case AnalyserEquationAst::Type::AND: + // a && b -> 1.0 or 0.0 (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode((!leftIsZero && !rightIsZero) ? 1.0 : 0.0, ast->parent()); + } + + break; + case AnalyserEquationAst::Type::OR: + // a || b -> 1.0 or 0.0 (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode((!leftIsZero || !rightIsZero) ? 1.0 : 0.0, ast->parent()); + } + + break; + case AnalyserEquationAst::Type::XOR: + // a xor b -> 1.0 or 0.0 (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode((!leftIsZero != !rightIsZero) ? 1.0 : 0.0, ast->parent()); + } + + break; + case AnalyserEquationAst::Type::NOT: + // !a -> 1.0 or 0.0 (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(leftIsZero ? 1.0 : 0.0, ast->parent()); + } + + break; + + // Arithmetic operators. + + case AnalyserEquationAst::Type::PLUS: { + if (rightExists) { + // Binary plus cases. + + // a + b -> c (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode(leftValue + rightValue, ast->parent()); + } + + // 0.0 + a -> a. + + if (leftIsZero) { + rightAst->setParent(ast->parent()); + + return rightAst; + } + + // a + 0.0 -> a. + + if (rightIsZero) { + leftAst->setParent(ast->parent()); + + return leftAst; + } + } else { + // Unary plus cases. + + // +a -> a. + + leftAst->setParent(ast->parent()); + + return leftAst; + } + + break; + } + case AnalyserEquationAst::Type::MINUS: + if (rightExists) { + // Binary minus cases. + + // a - b -> c (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode(leftValue - rightValue, ast->parent()); + } + + // 0.0 - a -> -a. + + if (leftIsZero) { + return makeUnaryMinus(rightAst, ast->parent()); + } + + // a - 0.0 -> a. + + if (rightIsZero) { + leftAst->setParent(ast->parent()); + + return leftAst; + } + } else { + // Unary minus cases. + + // -a -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(-leftValue, ast->parent()); + } + + // -(-a) -> a. + + auto leftAstRightChild = leftAst->rightChild(); + + if ((leftAst->type() == AnalyserEquationAst::Type::MINUS) + && (leftAstRightChild == nullptr)) { + auto res = leftAst->leftChild(); + + res->setParent(ast->parent()); + + return res; + } + + // Push the negation down to the leaves of additive/subtractive trees (i.e. -(a + b - c) -> -a - b + c). + + auto negateAdditiveSubtree = [&](const auto &selfNegate, const AnalyserEquationAstPtr &subtree, + const AnalyserEquationAstPtr &parentAst) -> AnalyserEquationAstPtr { + // -(a + b) -> -a - b. + + if (subtree->type() == AnalyserEquationAst::Type::PLUS) { + auto res = AnalyserEquationAst::create(); + + res->setType(AnalyserEquationAst::Type::PLUS); + res->setParent(parentAst); + + auto negatedLeft = selfNegate(selfNegate, subtree->leftChild(), res); + auto negatedRight = selfNegate(selfNegate, subtree->rightChild(), res); + + res->setLeftChild(negatedLeft); + res->setRightChild(negatedRight); + + negatedLeft->setParent(res); + negatedRight->setParent(res); + + return simplifyAst(res); + } + + // -(a - b) -> -a + b. + + if ((subtree->type() == AnalyserEquationAst::Type::MINUS) + && (subtree->rightChild() != nullptr)) { + auto res = AnalyserEquationAst::create(); + + res->setType(AnalyserEquationAst::Type::PLUS); + res->setParent(parentAst); + + auto negatedLeft = selfNegate(selfNegate, subtree->leftChild(), res); + auto right = subtree->rightChild(); + + res->setLeftChild(negatedLeft); + res->setRightChild(right); + + negatedLeft->setParent(res); + right->setParent(res); + + return simplifyAst(res); + } + + return makeUnaryMinus(subtree, parentAst); + }; + + // -(a ± b) -> -a ∓ b. + + auto leftAstType = leftAst->type(); + + if ((leftAstType == AnalyserEquationAst::Type::PLUS) + || (leftAstType == AnalyserEquationAst::Type::MINUS)) { + return simplifyAst(negateAdditiveSubtree(negateAdditiveSubtree, leftAst, ast->parent())); + } + + // -((a ± b) */ c) -> (-a ∓ -b) */ c. + + auto leftAstLeftChild = leftAst->leftChild(); + + if (((leftAstType == AnalyserEquationAst::Type::TIMES) || (leftAstType == AnalyserEquationAst::Type::DIVIDE)) + && ((leftAstLeftChild->type() == AnalyserEquationAst::Type::PLUS) + || (leftAstLeftChild->type() == AnalyserEquationAst::Type::MINUS))) { + auto res = AnalyserEquationAst::create(); + + res->setType(leftAstType); + res->setParent(ast->parent()); + + auto negatedLeft = negateAdditiveSubtree(negateAdditiveSubtree, leftAstLeftChild, res); + auto right = leftAstRightChild; + + res->setLeftChild(negatedLeft); + res->setRightChild(right); + + negatedLeft->setParent(res); + right->setParent(res); + + return simplifyAst(res); + } + } + + break; + case AnalyserEquationAst::Type::TIMES: { + // a * b -> c (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode(leftValue * rightValue, ast->parent()); + } + + // 0.0 * a -> 0.0. + + if (leftIsZero) { + return makeCnNode(0.0, ast->parent()); + } + + // a * 0.0 -> 0.0. + + if (rightIsZero) { + return makeCnNode(0.0, ast->parent()); + } + + // 1.0 * a -> a. + + if (leftIsOne) { + rightAst->setParent(ast->parent()); + + return rightAst; + } + + // a * 1.0 -> a. + + if (rightIsOne) { + leftAst->setParent(ast->parent()); + + return leftAst; + } + + // -1.0 * a -> -a. + + if (leftIsNegOne) { + return makeUnaryMinus(rightAst, ast->parent()); + } + + // a * -1.0 -> -a. + + if (rightIsNegOne) { + return makeUnaryMinus(leftAst, ast->parent()); + } + + // ( 1.0 / a ) * b -> b / a. + + if ((leftAst->type() == AnalyserEquationAst::Type::DIVIDE) && isCnValue(leftAst->leftChild(), 1.0)) { + auto res = AnalyserEquationAst::create(); + auto leftAstRightChild = leftAst->rightChild(); + + res->setType(AnalyserEquationAst::Type::DIVIDE); + res->setParent(ast->parent()); + res->setLeftChild(rightAst); + res->setRightChild(leftAstRightChild); + + rightAst->setParent(res); + leftAstRightChild->setParent(res); + + return simplifyAst(res); + } + + // a * ( 1.0 / b ) -> a / b. + + if ((rightAst->type() == AnalyserEquationAst::Type::DIVIDE) && isCnValue(rightAst->leftChild(), 1.0)) { + auto res = AnalyserEquationAst::create(); + auto rightAstRightChild = rightAst->rightChild(); + + res->setType(AnalyserEquationAst::Type::DIVIDE); + res->setParent(ast->parent()); + res->setLeftChild(leftAst); + res->setRightChild(rightAstRightChild); + + leftAst->setParent(res); + rightAstRightChild->setParent(res); + + return simplifyAst(res); + } + + break; + } + case AnalyserEquationAst::Type::DIVIDE: { + // a / b -> c (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode(leftValue / rightValue, ast->parent()); + } + + // 0.0 / a -> 0.0. + + if (leftIsZero) { + return makeCnNode(0.0, ast->parent()); + } + + // a / 1.0 -> a. + + if (rightIsOne) { + leftAst->setParent(ast->parent()); + + return leftAst; + } + + // a / -1.0 -> -a. + + if (rightIsNegOne) { + return makeUnaryMinus(leftAst, ast->parent()); + } + + // 1.0 / (1.0 / a) -> a. + + if (leftIsOne && (rightAst->type() == AnalyserEquationAst::Type::DIVIDE) + && isCnValue(rightAst->leftChild(), 1.0)) { + auto res = rightAst->rightChild(); + + res->setParent(ast->parent()); + + return res; + } + + break; + } + case AnalyserEquationAst::Type::POWER: { + // a ^ b -> c (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode(std::pow(leftValue, rightValue), ast->parent()); + } + + // a ^ 0.0 -> 1.0. + + if (rightIsZero) { + return makeCnNode(1.0, ast->parent()); + } + + // 0.0 ^ a -> 0.0. + // Note: the case of 0.0^0.0 is already handled by the a^b -> c case above, since both 0.0 and 0.0 are + // constants. + + if (leftIsZero) { + return makeCnNode(0.0, ast->parent()); + } + + // 1.0 ^ a -> 1.0. + + if (leftIsOne) { + return makeCnNode(1.0, ast->parent()); + } + + // a ^ 1.0 -> a. + + if (rightIsOne) { + leftAst->setParent(ast->parent()); + + return leftAst; + } + + // a ^ -1.0 -> 1.0 / a. + + if (rightIsNegOne) { + auto res = AnalyserEquationAst::create(); + + res->setType(AnalyserEquationAst::Type::DIVIDE); + res->setParent(ast->parent()); + res->setLeftChild(makeCnNode(1.0, ast)); + res->setRightChild(leftAst); + + leftAst->setParent(res); + + return simplifyAst(res); + } + + break; + } + case AnalyserEquationAst::Type::ROOT: { + if (leftAst->type() == AnalyserEquationAst::Type::DEGREE) { + auto degreeAst = leftAst->leftChild(); + double degreeValue; + + if (cnValue(degreeAst, degreeValue)) { + // root(a, b) -> c (where a and b are constants). + + if (rightIsConstant) { + return makeCnNode(std::pow(rightValue, 1.0 / degreeValue), ast->parent()); + } + } + } else { + // sqrt(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::sqrt(leftValue), ast->parent()); + } + } + + break; + } + case AnalyserEquationAst::Type::ABS: + // |a| -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::abs(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::EXP: + // exp(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::exp(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::LN: + // ln(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::log(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::LOG: + if (leftAst->type() == AnalyserEquationAst::Type::LOGBASE) { + auto logBaseAst = leftAst->leftChild(); + double logBaseValue; + + if (cnValue(logBaseAst, logBaseValue)) { + // log(a, b) -> c (where a and b are constants). + + if (rightIsConstant) { + return makeCnNode(std::pow(rightValue, 1.0 / logBaseValue), ast->parent()); + } + } + } else { + // log(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::log(leftValue) / std::log(10.0), ast->parent()); + } + } + + break; + case AnalyserEquationAst::Type::CEILING: + // ceiling(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::ceil(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::FLOOR: + // floor(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::floor(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::MIN: + // min(a, b) -> c (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode(std::min(leftValue, rightValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::MAX: + // max(a, b) -> c (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode(std::max(leftValue, rightValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::REM: + // rem(a, b) -> c (where a and b are constants). + + if (leftIsConstant && rightIsConstant) { + return makeCnNode(std::fmod(leftValue, rightValue), ast->parent()); + } + + break; + + // Trigonometric operators. + + case AnalyserEquationAst::Type::SIN: + // sin(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::sin(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::COS: + // cos(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::cos(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::TAN: + // tan(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::tan(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::SEC: + // sec(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(1.0 / std::cos(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::CSC: + // csc(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(1.0 / std::sin(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::COT: + // cot(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(1.0 / std::tan(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::SINH: + // sinh(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::sinh(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::COSH: + // cosh(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::cosh(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::TANH: + // tanh(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::tanh(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::SECH: + // sech(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(1.0 / std::cosh(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::CSCH: + // csch(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(1.0 / std::sinh(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::COTH: + // coth(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(1.0 / std::tanh(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::ASIN: + // asin(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::asin(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::ACOS: + // acos(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::acos(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::ATAN: + // atan(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::atan(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::ASEC: + // asec(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::acos(1.0 / leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::ACSC: + // acsc(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::asin(1.0 / leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::ACOT: + // acot(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::atan(1.0 / leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::ASINH: + // asinh(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::asinh(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::ACOSH: + // acosh(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::acosh(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::ATANH: + // atanh(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::atanh(leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::ASECH: + // asech(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::acosh(1.0 / leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::ACSCH: + // acsch(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::asinh(1.0 / leftValue), ast->parent()); + } + + break; + case AnalyserEquationAst::Type::ACOTH: + // acoth(a) -> b (where a is a constant). + + if (leftIsConstant) { + return makeCnNode(std::atanh(1.0 / leftValue), ast->parent()); + } + + break; + default: + break; + } + + return ast; +} + +AnalyserEquationAstPtr Analyser::AnalyserImpl::symEngineToAst(const SEExpression &seExpression, + const AnalyserEquationAstPtr &parentAst, + const OSName2OSInfoMap *osName2osInfoMap) +{ + // Swap the LHS and RHS of the equation, if needed. + + auto seExpressionArgs = seExpression->get_args(); + auto seExpressionArgsSize = seExpressionArgs.size(); + auto seExpressionLhs = (seExpressionArgsSize > 0) ? seExpressionArgs.front() : SEExpression(); + auto seExpressionRhs = (seExpressionArgsSize > 1) ? seExpressionArgs.back() : SEExpression(); + + if ((parentAst == nullptr) + && ((seExpressionLhs->get_type_code() != SymEngine::SYMENGINE_SYMBOL) + || ((osName2osInfoMap != nullptr) + && (osName2osInfoMap->count(SymEngine::rcp_dynamic_cast(seExpressionLhs)->get_name()) > 0)))) { + std::swap(seExpressionArgs.front(), seExpressionArgs.back()); + } + + // Our top AST node. + + auto res = AnalyserEquationAst::create(); + + res->setParent(parentAst); + + // Check the type of the SymEngine expression and return its AST equivalent, recursively converting its arguments as + // needed. + + auto cnValueString = [](double value) { + auto res = convertToString(value); + + if ((res.find('.') == std::string::npos) && (res.find('e') == std::string::npos)) { + res += ".0"; + } + + return res; + }; + + auto currentAst = res; + + switch (seExpression->get_type_code()) { + // Relational and logical operators. + + case SymEngine::SYMENGINE_EQUALITY: + // Convert to either AnalyserEquationAst::Type::EQUALITY or AnalyserEquationAst::Type::EQ depending on whether + // we are at the top level or not. + + currentAst->setType((parentAst == nullptr) ? + AnalyserEquationAst::Type::EQUALITY : + AnalyserEquationAst::Type::EQ); + + break; + case SymEngine::SYMENGINE_UNEQUALITY: + currentAst->setType(AnalyserEquationAst::Type::NEQ); + + break; + case SymEngine::SYMENGINE_STRICTLESSTHAN: + currentAst->setType(AnalyserEquationAst::Type::LT); + + break; + case SymEngine::SYMENGINE_LESSTHAN: + currentAst->setType(AnalyserEquationAst::Type::LEQ); + + break; + + // Note: AnalyserEquationAst::Type::GT and AnalyserEquationAst::Type::GEQ are not accounted for since SymEngine + // doesn't have strict greater than and greater than or equal to operators. + + case SymEngine::SYMENGINE_AND: + currentAst->setType(AnalyserEquationAst::Type::AND); + + break; + case SymEngine::SYMENGINE_OR: + currentAst->setType(AnalyserEquationAst::Type::OR); + + break; + case SymEngine::SYMENGINE_XOR: + currentAst->setType(AnalyserEquationAst::Type::XOR); + + break; + case SymEngine::SYMENGINE_NOT: + currentAst->setType(AnalyserEquationAst::Type::NOT); + + break; + + // Arithmetic operators. + + case SymEngine::SYMENGINE_ADD: + currentAst->setType(AnalyserEquationAst::Type::PLUS); + + break; + + // Note: AnalyserEquationAst::Type::MINUS is not accounted for since SymEngine doesn't have a minus operator. + + case SymEngine::SYMENGINE_MUL: + currentAst->setType(AnalyserEquationAst::Type::TIMES); + + break; + + // Note: AnalyserEquationAst::Type::DIVIDE is not accounted for since SymEngine doesn't have a divide operator. + + case SymEngine::SYMENGINE_POW: { + auto base = seExpressionArgs.front(); + + if ((base->get_type_code() == SymEngine::SYMENGINE_CONSTANT) + && SymEngine::eq(*SymEngine::rcp_static_cast(base), *SymEngine::E)) { + currentAst->setType(AnalyserEquationAst::Type::EXP); + currentAst->setLeftChild(symEngineToAst(seExpressionArgs.back(), currentAst, osName2osInfoMap)); + + return res; + } + + currentAst->setType(AnalyserEquationAst::Type::POWER); + + break; + } + + // Note: AnalyserEquationAst::Type::ROOT is not accounted for since SymEngine doesn't have a root operator. + + case SymEngine::SYMENGINE_ABS: + currentAst->setType(AnalyserEquationAst::Type::ABS); + + break; + + // Note: AnalyserEquationAst::Type::EXP is not accounted for since SymEngine doesn't have an exponential + // operator. + + case SymEngine::SYMENGINE_LOG: + currentAst->setType(AnalyserEquationAst::Type::LN); + + break; + + // Note: SymEngine doesn't have a log function with a base argument, so although we can easily convert + // AnalyserEquationAst::Type::LOG to SymEngine::SYMENGINE_LOG, to do the reverse is a bit more involved + // and not worth the effort at the moment, so we just convert SymEngine::SYMENGINE_LOG to + // AnalyserEquationAst::Type::LN. + + case SymEngine::SYMENGINE_CEILING: + currentAst->setType(AnalyserEquationAst::Type::CEILING); + + break; + case SymEngine::SYMENGINE_FLOOR: + currentAst->setType(AnalyserEquationAst::Type::FLOOR); + + break; + case SymEngine::SYMENGINE_MIN: + currentAst->setType(AnalyserEquationAst::Type::MIN); + + break; + case SymEngine::SYMENGINE_MAX: + currentAst->setType(AnalyserEquationAst::Type::MAX); + + break; + + // Note: AnalyserEquationAst::Type::REM is accounted for in the default case since SymEngine doesn't have a + // built-in remainder function, so we converted it to a function symbol with the name "mod". + + // Calculus elements. + + // Note: we handle derivatives separately, so we are not accounting for SymEngine::SYMENGINE_DERIVATIVE here. + + // Trigonometric operators. + + case SymEngine::SYMENGINE_SIN: + currentAst->setType(AnalyserEquationAst::Type::SIN); + + break; + case SymEngine::SYMENGINE_COS: + currentAst->setType(AnalyserEquationAst::Type::COS); + + break; + case SymEngine::SYMENGINE_TAN: + currentAst->setType(AnalyserEquationAst::Type::TAN); + + break; + case SymEngine::SYMENGINE_SEC: + currentAst->setType(AnalyserEquationAst::Type::SEC); + + break; + case SymEngine::SYMENGINE_CSC: + currentAst->setType(AnalyserEquationAst::Type::CSC); + + break; + case SymEngine::SYMENGINE_COT: + currentAst->setType(AnalyserEquationAst::Type::COT); + + break; + case SymEngine::SYMENGINE_SINH: + currentAst->setType(AnalyserEquationAst::Type::SINH); + + break; + case SymEngine::SYMENGINE_COSH: + currentAst->setType(AnalyserEquationAst::Type::COSH); + + break; + case SymEngine::SYMENGINE_TANH: + currentAst->setType(AnalyserEquationAst::Type::TANH); + + break; + case SymEngine::SYMENGINE_SECH: + currentAst->setType(AnalyserEquationAst::Type::SECH); + + break; + case SymEngine::SYMENGINE_CSCH: + currentAst->setType(AnalyserEquationAst::Type::CSCH); + + break; + case SymEngine::SYMENGINE_COTH: + currentAst->setType(AnalyserEquationAst::Type::COTH); + + break; + case SymEngine::SYMENGINE_ASIN: + currentAst->setType(AnalyserEquationAst::Type::ASIN); + + break; + case SymEngine::SYMENGINE_ACOS: + currentAst->setType(AnalyserEquationAst::Type::ACOS); + + break; + case SymEngine::SYMENGINE_ATAN: + currentAst->setType(AnalyserEquationAst::Type::ATAN); + + break; + case SymEngine::SYMENGINE_ASEC: + currentAst->setType(AnalyserEquationAst::Type::ASEC); + + break; + case SymEngine::SYMENGINE_ACSC: + currentAst->setType(AnalyserEquationAst::Type::ACSC); + + break; + case SymEngine::SYMENGINE_ACOT: + currentAst->setType(AnalyserEquationAst::Type::ACOT); + + break; + case SymEngine::SYMENGINE_ASINH: + currentAst->setType(AnalyserEquationAst::Type::ASINH); + + break; + case SymEngine::SYMENGINE_ACOSH: + currentAst->setType(AnalyserEquationAst::Type::ACOSH); + + break; + case SymEngine::SYMENGINE_ATANH: + currentAst->setType(AnalyserEquationAst::Type::ATANH); + + break; + case SymEngine::SYMENGINE_ASECH: + currentAst->setType(AnalyserEquationAst::Type::ASECH); + + break; + case SymEngine::SYMENGINE_ACSCH: + currentAst->setType(AnalyserEquationAst::Type::ACSCH); + + break; + case SymEngine::SYMENGINE_ACOTH: + currentAst->setType(AnalyserEquationAst::Type::ACOTH); + + break; + + // Token elements. + + case SymEngine::SYMENGINE_SYMBOL: { + // If the symbol is an opaque placeholder for a non-SymEngine-native AST subtree, then we substitute it back. + + auto seSymbol = SymEngine::rcp_dynamic_cast(seExpression); + + if (osName2osInfoMap != nullptr) { + auto it = osName2osInfoMap->find(seSymbol->get_name()); + + if (it != osName2osInfoMap->end()) { + return it->second.ast->clone(parentAst); + } + } + + // Otherwise, it's a regular variable. + + currentAst->setType(AnalyserEquationAst::Type::CI); + currentAst->setVariable(mSESymbol2AIVariableMap.at(seSymbol)->mVariable); + + break; + } + case SymEngine::SYMENGINE_INTEGER: + currentAst->setType(AnalyserEquationAst::Type::CN); + currentAst->setValue(cnValueString(static_cast(std::stoll(seExpression->__str__())))); + + break; + case SymEngine::SYMENGINE_REAL_DOUBLE: + currentAst->setType(AnalyserEquationAst::Type::CN); + currentAst->setValue(cnValueString(std::stod(seExpression->__str__()))); + + break; + case SymEngine::SYMENGINE_RATIONAL: { + currentAst->setType(AnalyserEquationAst::Type::CN); + currentAst->setValue(cnValueString(SymEngine::eval_double(*seExpression))); + + break; + } + + // Qualifier elements. + + // Note: we don't need to account for AnalyserEquationAst::Type::DEGREE, AnalyserEquationAst::Type::LOGBASE, and + // AnalyserEquationAst::Type::BVAR since we already account for them elsewhere. + + // Constants. + + // Note: we don't need to account for AnalyserEquationAst::Type::TRUE and AnalyserEquationAst::Type::FALSE. We + // use SymEngine::number(1.0) and SymEngine::number(0.0) to represent true and false, respectively, so + // they are converted to CN nodes rather than TRUE and FALSE nodes. + + case SymEngine::SYMENGINE_CONSTANT: + // It must be either e or Ï€. + + if (SymEngine::eq(*SymEngine::rcp_dynamic_cast(seExpression), *SymEngine::E)) { + currentAst->setType(AnalyserEquationAst::Type::E); + } else { + currentAst->setType(AnalyserEquationAst::Type::PI); + } + + break; + case SymEngine::SYMENGINE_INFTY: + currentAst->setType(AnalyserEquationAst::Type::INF); + + break; + default: { // SymEngine::SYMENGINE_FUNCTIONSYMBOL. + auto functionName = SymEngine::rcp_dynamic_cast(seExpression)->get_name(); + + if (functionName == "diff") { + currentAst->setType(AnalyserEquationAst::Type::DIFF); + + auto bVarAst = AnalyserEquationAst::create(); + + bVarAst->setType(AnalyserEquationAst::Type::BVAR); + bVarAst->setParent(currentAst); + bVarAst->setLeftChild(symEngineToAst(seExpressionLhs, bVarAst, osName2osInfoMap)); + + currentAst->setLeftChild(bVarAst); + currentAst->setRightChild(symEngineToAst(seExpressionRhs, currentAst, osName2osInfoMap)); + + return res; + } + + // "mod". + + currentAst->setType(AnalyserEquationAst::Type::REM); + + break; + } + } + + // All arguments (except the last one) are guaranteed to be left arguments in the AST tree. + + for (size_t i = 0; i + 1 < seExpressionArgsSize; ++i) { + currentAst->setLeftChild(symEngineToAst(seExpressionArgs[i], currentAst, osName2osInfoMap)); + + if (i < seExpressionArgsSize - 2) { + // There are more than two arguments left, so we need to create a copy of our original AST node. + + auto ast = AnalyserEquationAst::create(); + + ast->setType(currentAst->type()); + ast->setParent(currentAst); + ast->setValue(currentAst->value()); + ast->setVariable(currentAst->variable()); + + currentAst->setRightChild(ast); + + currentAst = ast; + } + } + + // The last argument is created and placed where appropriate. + + if (seExpressionArgsSize > 0) { + auto childAst = symEngineToAst(seExpressionArgs.back(), currentAst, osName2osInfoMap); + + if (seExpressionArgsSize == 1) { + currentAst->setLeftChild(childAst); + } else { + currentAst->setRightChild(childAst); + } + } + + return res; +} + +void Analyser::AnalyserImpl::replaceAstTree(const AnalyserInternalEquationPtr &equation, const AnalyserEquationAstPtr &ast) +{ + equation->mAst = ast; + + equation->mDependencies.clear(); + + equation->mVariables.clear(); + equation->mStateVariables.clear(); + equation->mAllVariables.clear(); + + AnalyserEquationAstPtrs astStack; + + astStack.push_back(ast); + + do { + auto crtAst = astStack.back(); + + astStack.pop_back(); + + if (crtAst->type() == AnalyserEquationAst::Type::CI) { + auto astVariable = crtAst->variable(); + + if (crtAst->parent()->type() == AnalyserEquationAst::Type::DIFF) { + equation->addStateVariable(internalVariable(astVariable)); + } else if (crtAst->parent()->type() != AnalyserEquationAst::Type::BVAR) { + equation->addVariable(internalVariable(astVariable)); + } + } + + if (crtAst->leftChild() != nullptr) { + astStack.push_back(crtAst->leftChild()); + } + + if (crtAst->rightChild() != nullptr) { + astStack.push_back(crtAst->rightChild()); + } + } while (!astStack.empty()); +} + +void Analyser::AnalyserImpl::updateEquationFromSEExpression(const AnalyserInternalEquationPtr &equation, + const SEExpression &seExpression) +{ + equation->mSEExpression = simplifySEExpression(seExpression); + + replaceAstTree(equation, simplifyAst(symEngineToAst(equation->mSEExpression))); +} + +void Analyser::AnalyserImpl::makeVariableKnown(const AnalyserInternalVariablePtr &variable, + const AnalyserInternalEquationPtr &equation) +{ + // Update all the other equations to consider this variable known. + + for (const auto &otherEquation : variable->mUnmatchedEquations) { + // Add the variable as a dependency for the equation, but only if it isn't the equation we are matching the + // variable with. + + if (otherEquation == equation) { + continue; + } + + otherEquation->mDependencies.push_back(variable); + + // Stop tracking the variable since it is now known. + + otherEquation->mVariables.erase(std::remove(otherEquation->mVariables.begin(), otherEquation->mVariables.end(), variable), otherEquation->mVariables.end()); + otherEquation->mStateVariables.erase(std::remove(otherEquation->mStateVariables.begin(), otherEquation->mStateVariables.end(), variable), otherEquation->mStateVariables.end()); + } + + // Stop tracking the variable since it is now known. + + variable->mUnmatchedEquations.clear(); +} + +bool Analyser::AnalyserImpl::matchVariableAndEquation(const AnalyserInternalVariablePtr &variable, + const AnalyserInternalEquationPtr &equation) +{ + // We first need to ensure that the variable is isolated in the equation, so we can match it. If it isn't, we try to + // rearrange the equation to isolate the variable. If we can't rearrange the equation, then we can't match the + // variable and the equation. + + if (!equation->isVariableIsolated(variable)) { + // If the equation has no native SymEngine representation (e.g., because it is a derivative or it contains a + // piecewise statement), then we build a temporary SymEngine expression by substituting every unsupported + // subtree with a fresh opaque symbol. SymEngine can then manipulate the enclosing expression algebraically, + // treating those subtrees as opaque unknowns, and the opaque symbols are resolved back to their original AST + // subtrees after solving. + + OSName2OSInfoMap osName2osInfoMap; + auto actualSEExpression = equation->mSEExpression; + + if (actualSEExpression.is_null()) { + [[maybe_unused]] auto [success, seExpression] = astToSymEngine(equation->mAst, &osName2osInfoMap); + + actualSEExpression = seExpression; + } + + // Try to rearrange the equation to isolate the variable. + + auto seSymbol = mAIVariable2SESymbolMap[variable]; + auto origSEExpression = equation->mSEExpression; + + equation->mSEExpression = actualSEExpression; + + auto rearrangedSEExpression = equation->rearrangeForSESymbol(seSymbol); + + equation->mSEExpression = origSEExpression; + + if (!rearrangedSEExpression.is_null()) { + // Update the equation using the rearranged SymEngine expression. When opaque symbols are present (i.e. the + // equation contains non-SymEngine-native nodes), then we reconstruct the AST directly using the opaque + // symbol to AST map. + + if (osName2osInfoMap.empty()) { + updateEquationFromSEExpression(equation, SymEngine::Eq(seSymbol, rearrangedSEExpression)); + } else { + auto simplifiedSEExpression = simplifySEExpression(SymEngine::Eq(seSymbol, rearrangedSEExpression)); + + replaceAstTree(equation, simplifyAst(symEngineToAst(simplifiedSEExpression, nullptr, &osName2osInfoMap))); + } + + equation->mHasBeenRearranged = true; + } else if (variable->mType == AnalyserInternalVariable::Type::STATE) { + // We can't rearrange the equation to isolate the variable. However, the variable is a state variable, so + // we can try to rearrange the equation to isolate the derivative of the variable instead. + + astToSymEngine(equation->mAst, &osName2osInfoMap); + + auto diffOpaqueSymbolName = "__diff_" + seSymbol->get_name(); + auto diffOpaqueSymbol = SymEngine::symbol(diffOpaqueSymbolName); + auto &seDiffExpression = osName2osInfoMap.at(diffOpaqueSymbolName).seDiffExpression; + + equation->mSEExpression = SymEngine::msubs(origSEExpression, {{seDiffExpression, diffOpaqueSymbol}}); + + rearrangedSEExpression = equation->rearrangeForSESymbol(diffOpaqueSymbol); + + equation->mSEExpression = origSEExpression; + + if (rearrangedSEExpression.is_null()) { + return false; + } + + updateEquationFromSEExpression(equation, SymEngine::Eq(seDiffExpression, rearrangedSEExpression)); + + equation->mHasBeenRearranged = true; + } else { + return false; + } + } else if (equation->isVariable(variable, equation->mAst->rightChild())) { + // The variable is on the right-hand side of the equation, so we swap the left-hand side and right-hand side of + // the equation to isolate the variable. + + auto leftChild = equation->mAst->leftChild(); + auto rightAst = equation->mAst->rightChild(); + + equation->mAst->setLeftChild(rightAst); + equation->mAst->setRightChild(leftChild); + leftChild->setParent(equation->mAst); + rightAst->setParent(equation->mAst); + + auto [success, seExpression] = astToSymEngine(equation->mAst); + + if (success) { + equation->mSEExpression = simplifySEExpression(seExpression); + } + } + + // If the equation was not rearranged, then simplify its AST directly. + + if (!equation->mHasBeenRearranged) { + replaceAstTree(equation, simplifyAst(equation->mAst)); + } + + // We can now match the variable and the equation. + + equation->addUnknownVariable(variable); + + variable->mMatchedEquation = equation; + + // Update all other variables in the equation to consider this variable known. + + for (const auto &otherVariables : {equation->mStateVariables, equation->mVariables}) { + for (const auto &otherVariable : otherVariables) { + // Don't update the variable we are matching. + + if (otherVariable == variable) { + continue; + } + + // Stop tracking the variable since it is now known and add it as a dependency for the equation. + + otherVariable->mUnmatchedEquations.erase(std::remove(otherVariable->mUnmatchedEquations.begin(), + otherVariable->mUnmatchedEquations.end(), + equation), + otherVariable->mUnmatchedEquations.end()); + + equation->mDependencies.push_back(otherVariable); + } + } + + // Stop tracking the variable and all other variables in the equation since they are now known. + + equation->mVariables.clear(); + equation->mStateVariables.clear(); + + makeVariableKnown(variable, equation); + + // Update the variable to use the variable from the equation's component that it is equivalent to. + + auto i = MAX_SIZE_T; + + while (true) { + auto localVariable = equation->mComponent->variable(++i); + + if (mAnalyserModel->areEquivalentVariables(variable->mVariable, localVariable)) { + variable->setVariable(localVariable, false); + + break; + } + } + + return true; +} + +void Analyser::AnalyserImpl::matchVariablesAndEquations(AnalyserInternalVariablePtrs &variables, + AnalyserInternalEquationPtrs &equations) +{ + // Initialise our matching by identifying which variables and equations are initially unknown, and the relationships + // between them. + + for (const auto &equation : equations) { + auto iter = equation->mVariables.begin(); + + while (iter != equation->mVariables.end()) { + auto variable = *iter; + + // Ignore the variables that do not require matching and, instead, add them as dependencies. + + if ((std::find(variables.begin(), variables.end(), variable) == variables.end()) + || (variable->mType == AnalyserInternalVariable::Type::STATE)) { + equation->mDependencies.push_back(variable); + + iter = equation->mVariables.erase(iter); + } else { + // The variable is unknown, so track it as a candidate for matching. + + variable->mUnmatchedEquations.push_back(equation); + + ++iter; + } + } + + // State variables are initially unknown, so track them as candidates for matching too. + + for (const auto &stateVariable : equation->mStateVariables) { + stateVariable->mUnmatchedEquations.push_back(equation); + } + } + + // Begin our matching process (see https://doi.org/10.1145/2666202.2666204 for more details). + + auto markEquationsAsNla = [&](const AnalyserInternalEquationPtrs &equations) { + for (const auto &equation : equations) { + equation->mType = AnalyserInternalEquation::Type::NLA; + + for (const auto &variable : equation->mAllVariables) { + if ((variable->mMatchedEquation == nullptr) + && (variable->mType != AnalyserInternalVariable::Type::VARIABLE_OF_INTEGRATION) + && (variable->mType != AnalyserInternalVariable::Type::INITIALISED)) { + variable->mType = AnalyserInternalVariable::Type::ALGEBRAIC_VARIABLE; + + equation->addUnknownVariable(variable); + } + } + } + }; + + AnalyserInternalVariablePtrs preTearingVariables; + AnalyserInternalVariablePtrs tearingVariables; + AnalyserInternalEquationPtrs allEquations = equations; + auto progressMade = false; + + while (variables.size() > 0) { + auto iterationProgress = false; + + // Match all our unmatched equations with a single unmatched variable it can rearrange for. + + bool localEquationProgress; + + do { + localEquationProgress = false; + + // Identify the equations that we can currently match. + + auto iter = equations.begin(); + + while (iter != equations.end()) { + auto equation = *iter; + + // We can't match equations that don't have one unmatched variable. + + if (equation->mVariables.size() + equation->mStateVariables.size() != 1) { + ++iter; + + continue; + } + + // We can only match equations where the variable is not the variable of integration and can be + // rearranged for. + + auto variable = (equation->mVariables.size() == 1) ? equation->mVariables.front() : equation->mStateVariables.front(); + + if (!matchVariableAndEquation(variable, equation)) { + ++iter; + + continue; + } + + // Keep track of the variable as one of our first variables by placing it before any variables that + // depend on it. + + auto insertIter = std::find_if(mFirstVariables.begin(), mFirstVariables.end(), [&](const auto &otherVariable) { + const auto &dependencies = otherVariable->mMatchedEquation->mDependencies; + + return std::find(dependencies.begin(), dependencies.end(), variable) != dependencies.end(); + }); + + mFirstVariables.insert(insertIter, variable); + + // Add the variable to our pre-tearing variables if we haven't identified any tearing variables yet. + + if (tearingVariables.size() == 0) { + preTearingVariables.push_back(variable); + } + + // Stop tracking the variable and the equation since they are now matched. + + variables.erase(std::remove(variables.begin(), variables.end(), variable), variables.end()); + + iter = equations.erase(iter); + + localEquationProgress = true; + progressMade = true; + iterationProgress = true; + } + } while (localEquationProgress); + + // Match all unmatched variables with a single unmatched equation it can be rearranged for. + + bool localVariableProgress; + + do { + localVariableProgress = false; + + // Identify the variables that we can currently match. + + auto iter = variables.begin(); + + while (iter != variables.end()) { + auto variable = *iter; + + // We can only match variables that are not external variables. + + if (variable->mIsExternalVariable) { + iter = variables.erase(iter); + + continue; + } + + // We can't match variables that have more than one unmatched equation. + + if (variable->mUnmatchedEquations.size() > 1) { + ++iter; + + continue; + } + + // We can only match variables that are not a variable with no equations left that include it. + + if (variable->mUnmatchedEquations.size() == 0) { + iter = variables.erase(iter); + + continue; + } + + // Check whether we can match the variable and the equation. + + auto equation = variable->mUnmatchedEquations.front(); + + if (matchVariableAndEquation(variable, equation)) { + // The variable and the equation can be matched, so keep track of the variable as one of our last + // variables and stop tracking the equation. + + mLastVariables.insert(mLastVariables.begin(), variable); + equations.erase(std::remove(equations.begin(), equations.end(), equation), equations.end()); + + progressMade = true; + } else { + // The variable and the equation can't be matched, so it's an "impossible assignment" which means + // that the variable should be considered as one of our tearing variables. + + tearingVariables.push_back(variable); + + makeVariableKnown(variable, nullptr); + } + + // Stop tracking the variable since it is now matched or a tearing variable. + + iter = variables.erase(iter); + + localVariableProgress = true; + iterationProgress = true; + } + } while (localVariableProgress); + + // Pick a tearing variable by choosing the variable that would make the greatest progress towards matching if it + // were known. We measure this by considering the following statistics: + // - the number of equations that would be made matched if this variable was known; and + // - the number of unmatched relationships involving the variable. + // The chosen tearing variable has the greatest sum of these two statistics. If several variables are tied, + // we can pick any of them, so we just pick the first one. + + size_t maxSum = 0; + AnalyserInternalVariablePtr tearingVariable; + + for (const auto &variable : variables) { + // Calculate the statistics for this variable. + + size_t matchMaking = 0; + + for (const auto &equation : variable->mUnmatchedEquations) { + if (equation->mStateVariables.size() + equation->mVariables.size() == 2) { + ++matchMaking; + } + } + + size_t sum = matchMaking + variable->mUnmatchedEquations.size(); + + // Check if this variable is a better tearing variable than our current best. + + if (sum > maxSum) { + maxSum = sum; + + tearingVariable = variable; + } + } + + // We have identified a tearing variable but we have more equations than variables, then we can't actually pick + // a tearing variable since we won't be able to make progress towards matching by making any variable known. + + if ((tearingVariable != nullptr) && (variables.size() > equations.size())) { + tearingVariable = nullptr; + } + + // If we have identified a tearing variable, then track it and consider it as known for the rest of the matching + // process. + + if (tearingVariable != nullptr) { + tearingVariables.push_back(tearingVariable); + + variables.erase(std::remove(variables.begin(), variables.end(), tearingVariable), variables.end()); + + makeVariableKnown(tearingVariable, nullptr); + + iterationProgress = true; + } + + // If we haven't made any progress towards matching in this iteration, then it means that we can stop the + // matching process. + + if (!iterationProgress) { + break; + } + } + + // If there are no tearing variables, then either we are done with matching or we have unmatched variables left. In + // the latter case, the remaining equations must be marked as NLA equations. + + if (tearingVariables.empty()) { + if (!variables.empty()) { + markEquationsAsNla(equations); + } + + return; + } + + // Reset the unmatched equations of tearing variables as they will be repopulated after equation substitution. + + for (const auto &tearingVariable : tearingVariables) { + tearingVariable->mUnmatchedEquations.clear(); + } + + // Create a substitution map for SymEngine expressions based on the equations we have matched so far. + + SymEngine::map_basic_basic substitutionMap; + + for (const auto &equation : allEquations) { + // Ignore the equations that we haven't managed to match or that we don't have a SymEngine equivalent for. + + if (std::find(equations.begin(), equations.end(), equation) != equations.end() + || equation->mSEExpression.is_null()) { + continue; + } + + // SymEngine may have swapped the LHS and RHS of our equation, so we need to check both sides of the equation to + // identify on which side our unknown variable is and thus determine the correct substitution. + + auto seSymbolFromSEExpression = [](const SEExpression &seExpression) { + SESymbol res; + + if (seExpression->get_type_code() == SymEngine::SYMENGINE_SYMBOL) { + res = SymEngine::rcp_static_cast(seExpression); + } + + return res; + }; + + auto seExpressionArgs = equation->mSEExpression->get_args(); + auto seExpressionLhs = seExpressionArgs.front(); + auto seExpressionRhs = seExpressionArgs.back(); + auto seSymbolLhs = seSymbolFromSEExpression(seExpressionLhs); + + auto unknownVariable = equation->mUnknownVariables.front(); + + if (std::find(preTearingVariables.begin(), preTearingVariables.end(), unknownVariable) != preTearingVariables.end()) { + continue; + } + + // We have identified the unknown variable and the correct substitution, so add it to our substitution map. + + if (!seSymbolLhs.is_null() + && (mSESymbol2AIVariableMap.at(seSymbolLhs) == unknownVariable)) { + substitutionMap[seExpressionLhs] = seExpressionRhs; + } else { + substitutionMap[seExpressionRhs] = seExpressionLhs; + } + } + + // Substitute the SymEngine expressions of all our equations and regenerate the AST tree for all our equations. + + for (const auto &equation : equations) { + // If the equation doesn't have a SymEngine equivalent, then we still need to "replace" its AST tree so that its + // internals get updated. + + if (equation->mSEExpression.is_null()) { + replaceAstTree(equation, equation->mAst); + + continue; + } + + // Do the substitution for this equation and then update the equation based on the result. + + for (size_t i = 0; i < substitutionMap.size(); ++i) { + equation->mSEExpression = SymEngine::msubs(equation->mSEExpression, substitutionMap); + } + + updateEquationFromSEExpression(equation, equation->mSEExpression); + } + + // We have made some progress towards matching variables and equations, so try again using our tearing variables. + + if (progressMade) { + matchVariablesAndEquations(tearingVariables, equations); + + return; + } + + // Our matching algorithm has stalled which means that the rest of the system must be classified as an NLA system. + + markEquationsAsNla(equations); +} + +void Analyser::AnalyserImpl::substituteVariablesInEquations() +{ + auto substituteVariables = [&](const auto &self, const AnalyserEquationAstPtr &ast, + const AnalyserInternalEquationPtr &internalEquation, + std::unordered_set &visitedEquations, + bool &substitutionComplete, const AnalyserEquationAstPtr &parentAst) -> AnalyserEquationAstPtr { + if (ast == nullptr) { + return nullptr; + } + + if (ast->type() == AnalyserEquationAst::Type::CI) { + auto matchedEquation = internalVariable(ast->variable())->mMatchedEquation; + + if ((matchedEquation != nullptr) + && (matchedEquation != internalEquation) + && matchedEquation->mHasBeenRearranged + && (visitedEquations.find(matchedEquation.get()) == visitedEquations.end())) { + visitedEquations.insert(matchedEquation.get()); + + auto substitutedAst = self(self, matchedEquation->mAst->rightChild(), internalEquation, visitedEquations, + substitutionComplete, parentAst); + + visitedEquations.erase(matchedEquation.get()); + + return substitutedAst; + } + + substitutionComplete = false; + + return ast->clone(parentAst); + } + + auto res = AnalyserEquationAst::create(); + + res->setType(ast->type()); + res->setValue(ast->value()); + res->setVariable(ast->variable()); + res->setParent(parentAst); + res->setLeftChild(self(self, ast->leftChild(), internalEquation, visitedEquations, substitutionComplete, res)); + res->setRightChild(self(self, ast->rightChild(), internalEquation, visitedEquations, substitutionComplete, res)); + + return res; + }; + + // Substitute all our matched variables in our equations to simplify them and potentially identify more matches. + + for (const auto &internalEquation : mInternalEquations) { + if (!internalEquation->mHasBeenRearranged) { + continue; + } + + auto substitutedEquationAst = AnalyserEquationAst::create(); + std::unordered_set visitedEquations = {internalEquation.get()}; + auto substitutionComplete = true; + + substitutedEquationAst->setType(AnalyserEquationAst::Type::EQUALITY); + substitutedEquationAst->setLeftChild(internalEquation->mAst->leftChild()->clone(substitutedEquationAst)); + substitutedEquationAst->setRightChild(substituteVariables(substituteVariables, internalEquation->mAst->rightChild(), + internalEquation, visitedEquations, substitutionComplete, + substitutedEquationAst)); + + if (!substitutionComplete) { + continue; + } + + auto simplifiedSubstitutedEquationAst = simplifyAst(substitutedEquationAst); + auto [success, seExpression] = astToSymEngine(simplifiedSubstitutedEquationAst); + + if (success) { + updateEquationFromSEExpression(internalEquation, seExpression); + } else { + replaceAstTree(internalEquation, simplifiedSubstitutedEquationAst); + } + } +} + +void Analyser::AnalyserImpl::classifyVariablesAndEquations() +{ + // Classify our analyser internal equations and analyser internal variables. + + for (const auto *orderedVariables : {&mFirstVariables, &mLastVariables}) { + for (const auto &orderedVariable : *orderedVariables) { + auto matchedEquation = orderedVariable->mMatchedEquation; + + // The matched equation of state variables and variables that should be state variables are always + // classified as ODEs. + + if ((orderedVariable->mType == AnalyserInternalVariable::Type::STATE) + || (orderedVariable->mType == AnalyserInternalVariable::Type::SHOULD_BE_STATE)) { + matchedEquation->mType = AnalyserInternalEquation::Type::ODE; + + continue; + } + + // For other variables, we need to inspect the variables that their matched equation depends on in order to + // classify them. + + std::unordered_set dependentVariables; + auto onlyConstants = true; + auto onlyComputedConstants = true; + + auto classifyDependentVariable = [&](const AnalyserInternalVariablePtr &dependentVariable) { + if (dependentVariable == orderedVariable) { + return; + } + + if (!dependentVariables.insert(dependentVariable.get()).second) { + return; + } + + if (dependentVariable->mIsExternalVariable) { + onlyConstants = false; + onlyComputedConstants = false; + + return; + } + + switch (dependentVariable->mType) { + case AnalyserInternalVariable::Type::INITIALISED: + case AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT: + case AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT: + onlyConstants = false; + + break; + default: + onlyConstants = false; + onlyComputedConstants = false; + + break; + } + }; + + for (const auto &dependentVariable : matchedEquation->mDependencies) { + classifyDependentVariable(dependentVariable); + } + + for (const auto &dependentVariable : matchedEquation->mAllVariables) { + classifyDependentVariable(dependentVariable); + } + + // Classify equations and variables. + + if (onlyConstants) { + orderedVariable->mType = AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT; + matchedEquation->mType = AnalyserInternalEquation::Type::CONSTANT; + } else if (onlyComputedConstants) { + orderedVariable->mType = AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT; + matchedEquation->mType = AnalyserInternalEquation::Type::COMPUTED_CONSTANT; + } else { + orderedVariable->mType = AnalyserInternalVariable::Type::ALGEBRAIC_VARIABLE; + matchedEquation->mType = AnalyserInternalEquation::Type::ALGEBRAIC; + } + } + } + + // Mark any remaining unknown variables as initialised variables, should they be external variables. + + for (const auto &internalVariable : mInternalVariables) { + if (internalVariable->mIsExternalVariable && (internalVariable->mType == AnalyserInternalVariable::Type::UNKNOWN)) { + internalVariable->mType = AnalyserInternalVariable::Type::INITIALISED; + } + } + + // Mark any remaining equations with no unknown variables as NLAs. + + for (const auto &internalEquation : mInternalEquations) { + if (internalEquation->mUnknownVariables.empty() && (internalEquation->mType == AnalyserInternalEquation::Type::UNKNOWN)) { + internalEquation->mType = AnalyserInternalEquation::Type::NLA; + } + } +} + +} // namespace libcellml diff --git a/src/annotator.cpp b/src/annotator.cpp index 715997d9af..572248a311 100644 --- a/src/annotator.cpp +++ b/src/annotator.cpp @@ -17,6 +17,7 @@ limitations under the License. #include "libcellml/annotator.h" #include +#include #include #include @@ -236,13 +237,17 @@ void Annotator::AnnotatorImpl::listComponentIdsAndItems(const ComponentPtr &comp if (idList.count(id) != 0) { // Get the range of items with this identifier: auto rangePair = idList.equal_range(id); + auto compVar = owningComponent(variable); + auto compEquivVar = owningComponent(equivalentVariable); for (auto it = rangePair.first; it != rangePair.second; ++it) { // Make sure it's also a CONNECTION item. if (it->second->type() == CellmlElementType::CONNECTION) { auto testPair = it->second->variablePair(); - if ((owningComponent(testPair->variable1()) == owningComponent(equivalentVariable)) && (owningComponent(testPair->variable2()) == owningComponent(variable))) { - found = true; - } else if ((owningComponent(testPair->variable2()) == owningComponent(equivalentVariable)) && (owningComponent(testPair->variable1()) == owningComponent(variable))) { + auto compVar1 = owningComponent(testPair->variable1()); + auto compVar2 = owningComponent(testPair->variable2()); + + if (((compVar1 == compEquivVar) && (compVar2 == compVar)) + || ((compVar2 == compEquivVar) && (compVar1 == compVar))) { found = true; } } @@ -352,7 +357,7 @@ AnyCellmlElementPtr Annotator::AnnotatorImpl::convertToWeak(const AnyCellmlEleme converted->mPimpl->mType = type; - switch (item->type()) { + switch (type) { case CellmlElementType::COMPONENT: case CellmlElementType::COMPONENT_REF: { ComponentWeakPtr weakComponent = item->component(); @@ -517,7 +522,7 @@ void Annotator::AnnotatorImpl::addIssueInvalidArgument(CellmlElementType type) void Annotator::AnnotatorImpl::addIssueNonUnique(const std::string &id) { auto issue = Issue::IssueImpl::create(); - issue->mPimpl->setDescription("The identifier '" + id + "' occurs " + std::to_string(mIdList.count(id)) + " times in the model so a unique item cannot be located."); + issue->mPimpl->setDescription("The identifier '" + id + "' occurs " + std::format("{}", mIdList.count(id)) + " times in the model so a unique item cannot be located."); issue->mPimpl->setLevel(Issue::Level::WARNING); issue->mPimpl->setReferenceRule(Issue::ReferenceRule::ANNOTATOR_ID_NOT_UNIQUE); addIssue(issue); @@ -1417,20 +1422,24 @@ size_t Annotator::itemCount(const std::string &id) void Annotator::AnnotatorImpl::doUpdateComponentHash(const ComponentPtr &component, std::string &idsString) { - for (size_t i = 0; i < component->variableCount(); ++i) { - idsString += "v=" + std::to_string(i) + component->variable(i)->id(); + const auto variableCount = component->variableCount(); + const auto resetCount = component->resetCount(); + const auto componentCount = component->componentCount(); + + for (size_t i = 0; i < variableCount; ++i) { + idsString += "v=" + std::format("{}", i) + component->variable(i)->id(); } - for (size_t i = 0; i < component->resetCount(); ++i) { + for (size_t i = 0; i < resetCount; ++i) { auto reset = component->reset(i); - idsString += "r=" + std::to_string(i) + reset->id() + "rv=" + reset->resetValueId() + "tv=" + reset->testValueId(); + idsString += "r=" + std::format("{}", i) + reset->id() + "rv=" + reset->resetValueId() + "tv=" + reset->testValueId(); } // Note that MathML identifiers are not yet included. - for (size_t i = 0; i < component->componentCount(); ++i) { + for (size_t i = 0; i < componentCount; ++i) { auto child = component->component(i); - idsString += "c=" + std::to_string(i) + child->id() + "ce=" + child->encapsulationId(); + idsString += "c=" + std::format("{}", i) + child->id() + "ce=" + child->encapsulationId(); doUpdateComponentHash(child, idsString); } } @@ -1448,21 +1457,21 @@ size_t Annotator::AnnotatorImpl::generateHash() auto importSources = getAllImportSources(model); i = 0; for (auto &importSource : importSources) { - idsString += "i=" + std::to_string(++i) + importSource->id(); + idsString += "i=" + std::format("{}", ++i) + importSource->id(); } for (i = 0; i < model->unitsCount(); ++i) { auto units = model->units(i); - idsString += "U=" + std::to_string(i) + units->id(); + idsString += "U=" + std::format("{}", i) + units->id(); for (size_t j = 0; j < units->unitCount(); ++j) { - idsString += "u=" + std::to_string(j) + units->unitId(j); + idsString += "u=" + std::format("{}", j) + units->unitId(j); } } for (i = 0; i < model->componentCount(); ++i) { auto component = model->component(i); - idsString += "c=" + std::to_string(i) + component->id(); - idsString += "cr=" + std::to_string(i) + component->encapsulationId(); + idsString += "c=" + std::format("{}", i) + component->id(); + idsString += "cr=" + std::format("{}", i) + component->encapsulationId(); doUpdateComponentHash(component, idsString); } diff --git a/src/api/libcellml/analyserequation.h b/src/api/libcellml/analyserequation.h index 7fcb8d367b..6cf861e20b 100644 --- a/src/api/libcellml/analyserequation.h +++ b/src/api/libcellml/analyserequation.h @@ -185,7 +185,7 @@ class LIBCELLML_EXPORT AnalyserEquation * * @return The states as a @c std::vector. */ - std::vector states() const; + const std::vector &states() const; /** * @brief Get the state, at @p index, computed by this @ref AnalyserEquation. @@ -214,7 +214,7 @@ class LIBCELLML_EXPORT AnalyserEquation * * @return The computed constants as a @c std::vector. */ - std::vector computedConstants() const; + const std::vector &computedConstants() const; /** * @brief Get the computed constant, at @p index, computed by this @ref AnalyserEquation. @@ -243,7 +243,7 @@ class LIBCELLML_EXPORT AnalyserEquation * * @return The algebraic variables as a @c std::vector. */ - std::vector algebraicVariables() const; + const std::vector &algebraicVariables() const; /** * @brief Get the algebraic variable, at @p index, computed by this @ref AnalyserEquation. @@ -272,7 +272,7 @@ class LIBCELLML_EXPORT AnalyserEquation * * @return The external variables as a @c std::vector. */ - std::vector externalVariables() const; + const std::vector &externalVariables() const; /** * @brief Get the external variable, at @p index, computed by this @ref AnalyserEquation. diff --git a/src/api/libcellml/analyserequationast.h b/src/api/libcellml/analyserequationast.h index 2467de1126..4fbc6ee1c9 100644 --- a/src/api/libcellml/analyserequationast.h +++ b/src/api/libcellml/analyserequationast.h @@ -190,7 +190,7 @@ class LIBCELLML_EXPORT AnalyserEquationAst * * @return The value. */ - std::string value() const; + const std::string &value() const; /** * @brief Set the value for this @ref AnalyserEquationAst. @@ -278,6 +278,17 @@ class LIBCELLML_EXPORT AnalyserEquationAst */ void setRightChild(const AnalyserEquationAstPtr &rightChild); + /** + * @brief Clone this @ref AnalyserEquationAst. + * + * Create a deep copy of this @ref AnalyserEquationAst, optionally assigning a new parent to the cloned root node. + * + * @param parentAst The optional parent for the cloned root node. + * + * @return The cloned @ref AnalyserEquationAst. + */ + AnalyserEquationAstPtr clone(const AnalyserEquationAstPtr &parentAst = nullptr) const; + /** * @brief Swap the left and right children of this @ref AnalyserEquationAst. * diff --git a/src/api/libcellml/analyserexternalvariable.h b/src/api/libcellml/analyserexternalvariable.h index 2f37eca126..bbcae50b0a 100644 --- a/src/api/libcellml/analyserexternalvariable.h +++ b/src/api/libcellml/analyserexternalvariable.h @@ -227,7 +227,7 @@ class LIBCELLML_EXPORT AnalyserExternalVariable * * @return The dependencies as a @c std::vector. */ - std::vector dependencies() const; + const std::vector &dependencies() const; /** * @brief Get the number of dependencies of this @ref AnalyserExternalVariable. diff --git a/src/api/libcellml/analysermodel.h b/src/api/libcellml/analysermodel.h index b264be7729..e5b1169173 100644 --- a/src/api/libcellml/analysermodel.h +++ b/src/api/libcellml/analysermodel.h @@ -137,7 +137,7 @@ class LIBCELLML_EXPORT AnalyserModel * * @return The states as a @c std::vector. */ - std::vector states() const; + const std::vector &states() const; /** * @brief Get the state at @p index. @@ -167,7 +167,7 @@ class LIBCELLML_EXPORT AnalyserModel * * @return The constants as a @c std::vector. */ - std::vector constants() const; + const std::vector &constants() const; /** * @brief Get the constant at @p index. @@ -197,7 +197,7 @@ class LIBCELLML_EXPORT AnalyserModel * * @return The computed constants as a @c std::vector. */ - std::vector computedConstants() const; + const std::vector &computedConstants() const; /** * @brief Get the computed constant at @p index. @@ -227,7 +227,7 @@ class LIBCELLML_EXPORT AnalyserModel * * @return The algebraic variables as a @c std::vector. */ - std::vector algebraicVariables() const; + const std::vector &algebraicVariables() const; /** * @brief Get the algebraic variable at @p index. @@ -257,7 +257,7 @@ class LIBCELLML_EXPORT AnalyserModel * * @return The external variables as a @c std::vector. */ - std::vector externalVariables() const; + const std::vector &externalVariables() const; /** * @brief Get the external variable at @p index. @@ -298,7 +298,7 @@ class LIBCELLML_EXPORT AnalyserModel * * @return The analyser equations as a @c std::vector. */ - std::vector analyserEquations() const; + const std::vector &analyserEquations() const; /** * @brief Get the analyser equation at @p index. diff --git a/src/api/libcellml/component.h b/src/api/libcellml/component.h index 6bc45d969e..54e1356c9a 100644 --- a/src/api/libcellml/component.h +++ b/src/api/libcellml/component.h @@ -107,7 +107,7 @@ class LIBCELLML_EXPORT Component: public ComponentEntity, public ImportedEntity * * @return @c std::string math for this component. */ - std::string math() const; + const std::string &math() const; /** * @brief Set the math string for this component. diff --git a/src/api/libcellml/componententity.h b/src/api/libcellml/componententity.h index 142604f70e..48e8df9e30 100644 --- a/src/api/libcellml/componententity.h +++ b/src/api/libcellml/componententity.h @@ -289,7 +289,7 @@ class LIBCELLML_EXPORT ComponentEntity: public NamedEntity * * @return The @c std::string of the encapsulation identifier. */ - std::string encapsulationId() const; + const std::string &encapsulationId() const; /** * @brief Remove the encapsulation identifier for this entity. diff --git a/src/api/libcellml/entity.h b/src/api/libcellml/entity.h index 70c694add6..86eb1e5429 100644 --- a/src/api/libcellml/entity.h +++ b/src/api/libcellml/entity.h @@ -56,7 +56,7 @@ class LIBCELLML_EXPORT Entity * * @return The @c std::string document identifier for this entity. */ - std::string id() const; + const std::string &id() const; /** * @brief Remove the identifier for this entity. diff --git a/src/api/libcellml/generatorprofile.h b/src/api/libcellml/generatorprofile.h index b79c729709..721745f98d 100644 --- a/src/api/libcellml/generatorprofile.h +++ b/src/api/libcellml/generatorprofile.h @@ -129,7 +129,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "equality" operator. */ - std::string equalityString() const; + const std::string &equalityString() const; /** * @brief Set the @c std::string representing the MathML "equality" @@ -152,7 +152,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "equal to" operator. */ - std::string eqString() const; + const std::string &eqString() const; /** * @brief Set the @c std::string representing the MathML "equal to" @@ -175,7 +175,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "not equal to" * operator. */ - std::string neqString() const; + const std::string &neqString() const; /** * @brief Set the @c std::string representing the MathML "not equal to" @@ -196,7 +196,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "less than" operator. */ - std::string ltString() const; + const std::string <String() const; /** * @brief Set the @c std::string representing the MathML "less than" @@ -219,7 +219,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "less than or equal * to" operator. */ - std::string leqString() const; + const std::string &leqString() const; /** * @brief Set the @c std::string representing the MathML "less than or @@ -243,7 +243,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "greater than" * operator. */ - std::string gtString() const; + const std::string >String() const; /** * @brief Set the @c std::string representing the MathML "greater than" @@ -266,7 +266,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "greater than or * equal to" operator. */ - std::string geqString() const; + const std::string &geqString() const; /** * @brief Set the @c std::string representing the MathML "greater than or @@ -287,7 +287,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "and" operator. */ - std::string andString() const; + const std::string &andString() const; /** * @brief Set the @c std::string representing the MathML "and" operator. @@ -306,7 +306,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "or" operator. */ - std::string orString() const; + const std::string &orString() const; /** * @brief Set the @c std::string representing the MathML "or" operator. @@ -327,7 +327,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "exclusive or" * operator. */ - std::string xorString() const; + const std::string &xorString() const; /** * @brief Set the @c std::string representing the MathML "exclusive or" @@ -347,7 +347,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "not" operator. */ - std::string notString() const; + const std::string ¬String() const; /** * @brief Set the @c std::string representing the MathML "not" operator. @@ -579,7 +579,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "plus" operator. */ - std::string plusString() const; + const std::string &plusString() const; /** * @brief Set the @c std::string representing the MathML "plus" operator. @@ -598,7 +598,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "minus" operator. */ - std::string minusString() const; + const std::string &minusString() const; /** * @brief Set the @c std::string representing the MathML "minus" operator. @@ -617,7 +617,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "times" operator. */ - std::string timesString() const; + const std::string ×String() const; /** * @brief Set the @c std::string representing the MathML "times" operator. @@ -636,7 +636,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "divide" operator. */ - std::string divideString() const; + const std::string ÷String() const; /** * @brief Set the @c std::string representing the MathML "divide" operator. @@ -658,7 +658,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "power" operator or * function. */ - std::string powerString() const; + const std::string &powerString() const; /** * @brief Set the @c std::string representing the MathML "power" operator or @@ -681,7 +681,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "square root" * function. */ - std::string squareRootString() const; + const std::string &squareRootString() const; /** * @brief Set the @c std::string representing the MathML "square root" @@ -701,7 +701,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "square" function. */ - std::string squareString() const; + const std::string &squareString() const; /** * @brief Set the @c std::string representing the MathML "square" function. @@ -723,7 +723,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "absolute value" * function. */ - std::string absoluteValueString() const; + const std::string &absoluteValueString() const; /** * @brief Set the @c std::string representing the MathML "absolute value" @@ -746,7 +746,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "exponential" * function. */ - std::string exponentialString() const; + const std::string &exponentialString() const; /** * @brief Set the @c std::string representing the MathML "exponential" @@ -769,7 +769,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "natural logarithm" * function. */ - std::string naturalLogarithmString() const; + const std::string &naturalLogarithmString() const; /** * @brief Set the @c std::string representing the MathML "natural logarithm" @@ -793,7 +793,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "common logarithm" * function. */ - std::string commonLogarithmString() const; + const std::string &commonLogarithmString() const; /** * @brief Set the @c std::string representing the MathML "common logarithm" @@ -814,7 +814,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "ceiling" function. */ - std::string ceilingString() const; + const std::string &ceilingString() const; /** * @brief Set the @c std::string representing the MathML "ceiling" function. @@ -833,7 +833,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "floor" function. */ - std::string floorString() const; + const std::string &floorString() const; /** * @brief Set the @c std::string representing the MathML "floor" function. @@ -852,7 +852,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "minimum" function. */ - std::string minString() const; + const std::string &minString() const; /** * @brief Set the @c std::string representing the MathML "minimum" function. @@ -871,7 +871,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "maximum" function. */ - std::string maxString() const; + const std::string &maxString() const; /** * @brief Set the @c std::string representing the MathML "maximum" function. @@ -891,7 +891,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "remainder" function. */ - std::string remString() const; + const std::string &remString() const; /** * @brief Set the @c std::string representing the MathML "remainder" @@ -933,7 +933,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "sine" function. */ - std::string sinString() const; + const std::string &sinString() const; /** * @brief Set the @c std::string representing the MathML "sine" function. @@ -952,7 +952,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "cosine" function. */ - std::string cosString() const; + const std::string &cosString() const; /** * @brief Set the @c std::string representing the MathML "cosine" function. @@ -971,7 +971,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "tangent" function. */ - std::string tanString() const; + const std::string &tanString() const; /** * @brief Set the @c std::string representing the MathML "tangent" function. @@ -990,7 +990,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "secant" function. */ - std::string secString() const; + const std::string &secString() const; /** * @brief Set the @c std::string representing the MathML "secant" function. @@ -1010,7 +1010,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "cosecant" function. */ - std::string cscString() const; + const std::string &cscString() const; /** * @brief Set the @c std::string representing the MathML "cosecant" @@ -1031,7 +1031,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "cotangent" function. */ - std::string cotString() const; + const std::string &cotString() const; /** * @brief Set the @c std::string representing the MathML "cotangent" @@ -1054,7 +1054,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "hyperbolic sine" * function. */ - std::string sinhString() const; + const std::string &sinhString() const; /** * @brief Set the @c std::string representing the MathML "hyperbolic sine" @@ -1078,7 +1078,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "hyperbolic cosine" * function. */ - std::string coshString() const; + const std::string &coshString() const; /** * @brief Set the @c std::string representing the MathML "hyperbolic cosine" @@ -1102,7 +1102,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "hyperbolic tangent" * function. */ - std::string tanhString() const; + const std::string &tanhString() const; /** * @brief Set the @c std::string representing the MathML "hyperbolic @@ -1126,7 +1126,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "hyperbolic secant" * function. */ - std::string sechString() const; + const std::string &sechString() const; /** * @brief Set the @c std::string representing the MathML "hyperbolic secant" @@ -1150,7 +1150,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "hyperbolic cosecant" * function. */ - std::string cschString() const; + const std::string &cschString() const; /** * @brief Set the @c std::string representing the MathML "hyperbolic @@ -1174,7 +1174,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "hyperbolic cotangent" * function. */ - std::string cothString() const; + const std::string &cothString() const; /** * @brief Set the @c std::string representing the MathML "hyperbolic @@ -1196,7 +1196,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "arc sine" function. */ - std::string asinString() const; + const std::string &asinString() const; /** * @brief Set the @c std::string representing the MathML "arc sine" @@ -1217,7 +1217,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "arc cosine" function. */ - std::string acosString() const; + const std::string &acosString() const; /** * @brief Set the @c std::string representing the MathML "arc cosine" @@ -1239,7 +1239,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "arc tangent" * function. */ - std::string atanString() const; + const std::string &atanString() const; /** * @brief Set the @c std::string representing the MathML "arc tangent" @@ -1260,7 +1260,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "arc secant" function. */ - std::string asecString() const; + const std::string &asecString() const; /** * @brief Set the @c std::string representing the MathML "arc secant" @@ -1283,7 +1283,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "arc cosecant" * function. */ - std::string acscString() const; + const std::string &acscString() const; /** * @brief Set the @c std::string representing the MathML "arc cosecant" @@ -1306,7 +1306,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "arc cotangent" * function. */ - std::string acotString() const; + const std::string &acotString() const; /** * @brief Set the @c std::string representing the MathML "arc cotangent" @@ -1329,7 +1329,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "arc hyperbolic sine" * function. */ - std::string asinhString() const; + const std::string &asinhString() const; /** * @brief Set the @c std::string representing the MathML "arc hyperbolic @@ -1353,7 +1353,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "arc hyperbolic * cosine" function. */ - std::string acoshString() const; + const std::string &acoshString() const; /** * @brief Set the @c std::string representing the MathML "arc hyperbolic @@ -1377,7 +1377,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "arc hyperbolic * tangent" function. */ - std::string atanhString() const; + const std::string &atanhString() const; /** * @brief Set the @c std::string representing the MathML "arc hyperbolic @@ -1401,7 +1401,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "arc hyperbolic * secant" function. */ - std::string asechString() const; + const std::string &asechString() const; /** * @brief Set the @c std::string representing the MathML "arc hyperbolic @@ -1425,7 +1425,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "arc hyperbolic * cosecant" function. */ - std::string acschString() const; + const std::string &acschString() const; /** * @brief Set the @c std::string representing the MathML "arc hyperbolic @@ -1449,7 +1449,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "arc hyperbolic * cotangent" function. */ - std::string acothString() const; + const std::string &acothString() const; /** * @brief Set the @c std::string representing the MathML "arc hyperbolic @@ -1475,7 +1475,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "if" part of a * "conditional" statement or operator. */ - std::string conditionalOperatorIfString() const; + const std::string &conditionalOperatorIfString() const; /** * @brief Set the @c std::string representing the MathML "if" part of a @@ -1499,7 +1499,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "else" part of a * "conditional" statement or operator. */ - std::string conditionalOperatorElseString() const; + const std::string &conditionalOperatorElseString() const; /** * @brief Set the @c std::string representing the MathML "else" part of a @@ -1523,7 +1523,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "if" part of a * "piecewise" statement. */ - std::string piecewiseIfString() const; + const std::string &piecewiseIfString() const; /** * @brief Set the @c std::string representing the MathML "if" part of a @@ -1547,7 +1547,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string representing the MathML "else" part of a * "piecewise" statement. */ - std::string piecewiseElseString() const; + const std::string &piecewiseElseString() const; /** * @brief Set the @c std::string representing the MathML "else" part of a @@ -1590,7 +1590,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "true" boolean. */ - std::string trueString() const; + const std::string &trueString() const; /** * @brief Set the @c std::string representing the MathML "true" boolean. @@ -1609,7 +1609,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "false" boolean. */ - std::string falseString() const; + const std::string &falseString() const; /** * @brief Set the @c std::string representing the MathML "false" boolean. @@ -1628,7 +1628,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "Euler's number". */ - std::string eString() const; + const std::string &eString() const; /** * @brief Set the @c std::string representing the MathML "Euler's number". @@ -1647,7 +1647,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "Ï€" constant. */ - std::string piString() const; + const std::string &piString() const; /** * @brief Set the @c std::string representing the MathML "Ï€" constant. @@ -1665,7 +1665,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "infinity" value. */ - std::string infString() const; + const std::string &infString() const; /** * @brief Set the @c std::string representing the MathML "infinity" value. @@ -1685,7 +1685,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string representing the MathML "not-a-number" value. */ - std::string nanString() const; + const std::string &nanString() const; /** * @brief Set the @c std::string representing the MathML "not-a-number" @@ -1707,7 +1707,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the "equal to" function implementation. */ - std::string eqFunctionString() const; + const std::string &eqFunctionString() const; /** * @brief Set the @c std::string for the "equal to" function implementation. @@ -1728,7 +1728,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the "not equal to" function * implementation. */ - std::string neqFunctionString() const; + const std::string &neqFunctionString() const; /** * @brief Set the @c std::string for the "not equal to" function @@ -1749,7 +1749,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the "less than" function implementation. */ - std::string ltFunctionString() const; + const std::string <FunctionString() const; /** * @brief Set the @c std::string for the "less than" function @@ -1772,7 +1772,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the "less than or equal to" function * implementation. */ - std::string leqFunctionString() const; + const std::string &leqFunctionString() const; /** * @brief Set the @c std::string for the "less than or equal to" function @@ -1795,7 +1795,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the "greater than" function * implementation. */ - std::string gtFunctionString() const; + const std::string >FunctionString() const; /** * @brief Set the @c std::string for the "greater than" function @@ -1818,7 +1818,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the "greater than or equal to" function * implementation. */ - std::string geqFunctionString() const; + const std::string &geqFunctionString() const; /** * @brief Set the @c std::string for the "greater than or equal to" function @@ -1839,7 +1839,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the "and" function implementation. */ - std::string andFunctionString() const; + const std::string &andFunctionString() const; /** * @brief Set the @c std::string for the "and" function implementation. @@ -1858,7 +1858,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the "or" function implementation. */ - std::string orFunctionString() const; + const std::string &orFunctionString() const; /** * @brief Set the @c std::string for the "or" function implementation. @@ -1879,7 +1879,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the "exclusive or" function * implementation. */ - std::string xorFunctionString() const; + const std::string &xorFunctionString() const; /** * @brief Set the @c std::string for the "exclusive or" function @@ -1899,7 +1899,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the "not" function implementation. */ - std::string notFunctionString() const; + const std::string ¬FunctionString() const; /** * @brief Set the @c std::string for the "not" function implementation. @@ -1918,7 +1918,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the "minimum" function implementation. */ - std::string minFunctionString() const; + const std::string &minFunctionString() const; /** * @brief Set the @c std::string for the "minimum" function implementation. @@ -1937,7 +1937,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the "maximum" function implementation. */ - std::string maxFunctionString() const; + const std::string &maxFunctionString() const; /** * @brief Set the @c std::string for the "maximum" function implementation. @@ -1958,7 +1958,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the "secant" function implementation. */ - std::string secFunctionString() const; + const std::string &secFunctionString() const; /** * @brief Set the @c std::string for the "secant" function implementation. @@ -1977,7 +1977,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the "cosecant" function implementation. */ - std::string cscFunctionString() const; + const std::string &cscFunctionString() const; /** * @brief Set the @c std::string for the "cosecant" function implementation. @@ -1997,7 +1997,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the "cotangent" function implementation. */ - std::string cotFunctionString() const; + const std::string &cotFunctionString() const; /** * @brief Set the @c std::string for the "cotangent" function @@ -2020,7 +2020,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the "hyperbolic secant" function * implementation. */ - std::string sechFunctionString() const; + const std::string &sechFunctionString() const; /** * @brief Set the @c std::string for the "hyperbolic secant" function @@ -2044,7 +2044,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the "hyperbolic cosecant" function * implementation. */ - std::string cschFunctionString() const; + const std::string &cschFunctionString() const; /** * @brief Set the @c std::string for the "hyperbolic cosecant" function @@ -2068,7 +2068,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the "hyperbolic cotangent" function * implementation. */ - std::string cothFunctionString() const; + const std::string &cothFunctionString() const; /** * @brief Set the @c std::string for the "hyperbolic cotangent" function @@ -2090,7 +2090,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the "arc secant" function implementation. */ - std::string asecFunctionString() const; + const std::string &asecFunctionString() const; /** * @brief Set the @c std::string for the "arc secant" function @@ -2112,7 +2112,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the "arc cosecant" function * implementation. */ - std::string acscFunctionString() const; + const std::string &acscFunctionString() const; /** * @brief Set the @c std::string for the "arc cosecant" function @@ -2135,7 +2135,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the "arc cotangent" function * implementation. */ - std::string acotFunctionString() const; + const std::string &acotFunctionString() const; /** * @brief Set the @c std::string for the "arc cotangent" function implementation. @@ -2157,7 +2157,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the "arc hyperbolic secant" function * implementation. */ - std::string asechFunctionString() const; + const std::string &asechFunctionString() const; /** * @brief Set the @c std::string for the "arc hyperbolic secant" function @@ -2181,7 +2181,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the "arc hyperbolic cosecant" function * implementation. */ - std::string acschFunctionString() const; + const std::string &acschFunctionString() const; /** * @brief Set the @c std::string for the "arc hyperbolic cosecant" function @@ -2205,7 +2205,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the "arc hyperbolic cotangent" function * implementation. */ - std::string acothFunctionString() const; + const std::string &acothFunctionString() const; /** * @brief Set the @c std::string for the "arc hyperbolic cotangent" function @@ -2228,7 +2228,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for a comment. */ - std::string commentString() const; + const std::string &commentString() const; /** * @brief Set the @c std::string for a comment. @@ -2247,7 +2247,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for an origin comment. */ - std::string originCommentString() const; + const std::string &originCommentString() const; /** * @brief Set the @c std::string for an origin comment. @@ -2271,7 +2271,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface file name. */ - std::string interfaceFileNameString() const; + const std::string &interfaceFileNameString() const; /** * @brief Set the @c std::string for the interface file name. @@ -2290,7 +2290,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface of a header. */ - std::string interfaceHeaderString() const; + const std::string &interfaceHeaderString() const; /** * @brief Set the @c std::string for the interface of a header. @@ -2309,7 +2309,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for an implementation header. */ - std::string implementationHeaderString() const; + const std::string &implementationHeaderString() const; /** * @brief Set the @c std::string for an implementation header. @@ -2332,7 +2332,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface of the version constant. */ - std::string interfaceVersionString() const; + const std::string &interfaceVersionString() const; /** * @brief Set the @c std::string for the interface of the version constant. @@ -2353,7 +2353,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of the version * constant. */ - std::string implementationVersionString() const; + const std::string &implementationVersionString() const; /** * @brief Set the @c std::string for the implementation of the version @@ -2376,7 +2376,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the interface of the libCellML version * constant. */ - std::string interfaceLibcellmlVersionString() const; + const std::string &interfaceLibcellmlVersionString() const; /** * @brief Set the @c std::string for the interface of the libCellML version @@ -2400,7 +2400,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of the libCellML * version constant. */ - std::string implementationLibcellmlVersionString() const; + const std::string &implementationLibcellmlVersionString() const; /** * @brief Set the @c std::string for the implementation of the libCellML @@ -2423,7 +2423,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface of the state count constant. */ - std::string interfaceStateCountString() const; + const std::string &interfaceStateCountString() const; /** * @brief Set the @c std::string for the interface of the state count @@ -2446,7 +2446,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of the state count * constant. */ - std::string implementationStateCountString() const; + const std::string &implementationStateCountString() const; /** * @brief Set the @c std::string for the implementation of the state count @@ -2471,7 +2471,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the interface of the constant count * constant. */ - std::string interfaceConstantCountString() const; + const std::string &interfaceConstantCountString() const; /** * @brief Set the @c std::string for the interface of the constant count @@ -2494,7 +2494,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of the constant count * constant. */ - std::string implementationConstantCountString() const; + const std::string &implementationConstantCountString() const; /** * @brief Set the @c std::string for the implementation of the constant @@ -2519,7 +2519,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the interface of the computed constant count * constant. */ - std::string interfaceComputedConstantCountString() const; + const std::string &interfaceComputedConstantCountString() const; /** * @brief Set the @c std::string for the interface of the computed constant count @@ -2542,7 +2542,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of the computed constant count * constant. */ - std::string implementationComputedConstantCountString() const; + const std::string &implementationComputedConstantCountString() const; /** * @brief Set the @c std::string for the implementation of the computed constant @@ -2567,7 +2567,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the interface of the algebraic variable count * constant. */ - std::string interfaceAlgebraicVariableCountString() const; + const std::string &interfaceAlgebraicVariableCountString() const; /** * @brief Set the @c std::string for the interface of the algebraic variable count @@ -2590,7 +2590,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of the algebraic variable count * constant. */ - std::string implementationAlgebraicVariableCountString() const; + const std::string &implementationAlgebraicVariableCountString() const; /** * @brief Set the @c std::string for the implementation of the algebraic @@ -2615,7 +2615,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the interface of the external variable count * constant. */ - std::string interfaceExternalVariableCountString() const; + const std::string &interfaceExternalVariableCountString() const; /** * @brief Set the @c std::string for the interface of the external variable count @@ -2638,7 +2638,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of the external variable count * constant. */ - std::string implementationExternalVariableCountString() const; + const std::string &implementationExternalVariableCountString() const; /** * @brief Set the @c std::string for the implementation of the external @@ -2663,7 +2663,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the data structure for the variable * information object. */ - std::string variableInfoObjectString() const; + const std::string &variableInfoObjectString() const; /** * @brief Set the @c std::string for the data structure for the variable @@ -2690,7 +2690,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the interface of some information about * the variable of integration. */ - std::string interfaceVoiInfoString() const; + const std::string &interfaceVoiInfoString() const; /** * @brief Set the @c std::string for the interface of some information about @@ -2714,7 +2714,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of some information * about the variable of integration. */ - std::string implementationVoiInfoString() const; + const std::string &implementationVoiInfoString() const; /** * @brief Set the @c std::string for the implementation of some information @@ -2740,7 +2740,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the interface of some information about * the different states. */ - std::string interfaceStateInfoString() const; + const std::string &interfaceStateInfoString() const; /** * @brief Set the @c std::string for the interface of some information about @@ -2764,7 +2764,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of some information * about the different states. */ - std::string implementationStateInfoString() const; + const std::string &implementationStateInfoString() const; /** * @brief Set the @c std::string for the implementation of some information @@ -2790,7 +2790,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the interface of some information about * the different constants. */ - std::string interfaceConstantInfoString() const; + const std::string &interfaceConstantInfoString() const; /** * @brief Set the @c std::string for the interface of some information about @@ -2814,7 +2814,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of some information * about the different constants. */ - std::string implementationConstantInfoString() const; + const std::string &implementationConstantInfoString() const; /** * @brief Set the @c std::string for the implementation of some information @@ -2840,7 +2840,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the interface of some information about * the different computed constants. */ - std::string interfaceComputedConstantInfoString() const; + const std::string &interfaceComputedConstantInfoString() const; /** * @brief Set the @c std::string for the interface of some information about @@ -2864,7 +2864,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of some information * about the different computed constants. */ - std::string implementationComputedConstantInfoString() const; + const std::string &implementationComputedConstantInfoString() const; /** * @brief Set the @c std::string for the implementation of some information @@ -2890,7 +2890,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the interface of some information about * the different algebraic variables. */ - std::string interfaceAlgebraicVariableInfoString() const; + const std::string &interfaceAlgebraicVariableInfoString() const; /** * @brief Set the @c std::string for the interface of some information about @@ -2914,7 +2914,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of some information * about the different algebraic variables. */ - std::string implementationAlgebraicVariableInfoString() const; + const std::string &implementationAlgebraicVariableInfoString() const; /** * @brief Set the @c std::string for the implementation of some information @@ -2940,7 +2940,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the interface of some information about * the different external variables. */ - std::string interfaceExternalVariableInfoString() const; + const std::string &interfaceExternalVariableInfoString() const; /** * @brief Set the @c std::string for the interface of some information about @@ -2964,7 +2964,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of some information * about the different external variables. */ - std::string implementationExternalVariableInfoString() const; + const std::string &implementationExternalVariableInfoString() const; /** * @brief Set the @c std::string for the implementation of some information @@ -2990,7 +2990,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for an entry in an array for some information * about a variable. */ - std::string variableInfoEntryString() const; + const std::string &variableInfoEntryString() const; /** * @brief Set the @c std::string for an entry in an array for some @@ -3014,7 +3014,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the name of the variable of integration. */ - std::string voiString() const; + const std::string &voiString() const; /** * @brief Set the @c std::string for the name of the variable of @@ -3034,7 +3034,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the name of the states array. */ - std::string statesArrayString() const; + const std::string &statesArrayString() const; /** * @brief Set the @c std::string for the name of the states array. @@ -3053,7 +3053,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the name of the rates array. */ - std::string ratesArrayString() const; + const std::string &ratesArrayString() const; /** * @brief Set the @c std::string for the name of the rates array. @@ -3072,7 +3072,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the name of the constants array. */ - std::string constantsArrayString() const; + const std::string &constantsArrayString() const; /** * @brief Set the @c std::string for the name of the constants array. @@ -3091,7 +3091,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the name of the computed constants array. */ - std::string computedConstantsArrayString() const; + const std::string &computedConstantsArrayString() const; /** * @brief Set the @c std::string for the name of the computed constants array. @@ -3110,7 +3110,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the name of the algebraic variables array. */ - std::string algebraicVariablesArrayString() const; + const std::string &algebraicVariablesArrayString() const; /** * @brief Set the @c std::string for the name of the algebraic variables array. @@ -3129,7 +3129,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the name of the external variables array. */ - std::string externalVariablesArrayString() const; + const std::string &externalVariablesArrayString() const; /** * @brief Set the @c std::string for the name of the external variables array. @@ -3155,7 +3155,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the type definition of an external * variable method. */ - std::string externalVariableMethodTypeDefinitionString(bool forDifferentialModel) const; + const std::string &externalVariableMethodTypeDefinitionString(bool forDifferentialModel) const; /** * @brief Set the @c std::string for the type definition of an external @@ -3184,7 +3184,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the call to the external variable method. */ - std::string externalVariableMethodCallString(bool forDifferentialModel) const; + const std::string &externalVariableMethodCallString(bool forDifferentialModel) const; /** * @brief Set the @c std::string for the call to the external variable @@ -3218,8 +3218,8 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the data structure for the root finding * information object. */ - std::string rootFindingInfoObjectString(bool forDifferentialModel, - bool withExternalVariables) const; + const std::string &rootFindingInfoObjectString(bool forDifferentialModel, + bool withExternalVariables) const; /** * @brief Set the @c std::string for the data structure for the root finding @@ -3247,7 +3247,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the external NLA solve method. */ - std::string externNlaSolveMethodString() const; + const std::string &externNlaSolveMethodString() const; /** * @brief Set the @c std::string for the external NLA solve method. @@ -3271,8 +3271,8 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the call to the find root method. */ - std::string findRootCallString(bool forDifferentialModel, - bool withExternalVariables) const; + const std::string &findRootCallString(bool forDifferentialModel, + bool withExternalVariables) const; /** * @brief Set the @c std::string for the call to the find root method. @@ -3304,8 +3304,8 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the find root method. */ - std::string findRootMethodString(bool forDifferentialModel, - bool withExternalVariables) const; + const std::string &findRootMethodString(bool forDifferentialModel, + bool withExternalVariables) const; /** * @brief Set the @c std::string for the find root method. @@ -3341,8 +3341,8 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the call to the NLA solve method. */ - std::string nlaSolveCallString(bool forDifferentialModel, - bool withExternalVariables) const; + const std::string &nlaSolveCallString(bool forDifferentialModel, + bool withExternalVariables) const; /** * @brief Set the @c std::string for the call to the NLA solve method. @@ -3377,8 +3377,8 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the objective function method. */ - std::string objectiveFunctionMethodString(bool forDifferentialModel, - bool withExternalVariables) const; + const std::string &objectiveFunctionMethodString(bool forDifferentialModel, + bool withExternalVariables) const; /** * @brief Set the @c std::string for the objective function method. @@ -3410,7 +3410,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the @c u array used in the objective function * and find root methods. */ - std::string uArrayString() const; + const std::string &uArrayString() const; /** * @brief Set the @c std::string for the @c u array used in the objective @@ -3436,7 +3436,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the @c f array used in the objective function * and find root methods. */ - std::string fArrayString() const; + const std::string &fArrayString() const; /** * @brief Set the @c std::string for the @c f array used in the objective @@ -3459,7 +3459,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface to create the states array. */ - std::string interfaceCreateStatesArrayMethodString() const; + const std::string &interfaceCreateStatesArrayMethodString() const; /** * @brief Set the @c std::string for the interface to create the states @@ -3482,7 +3482,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation to create the states * array. */ - std::string implementationCreateStatesArrayMethodString() const; + const std::string &implementationCreateStatesArrayMethodString() const; /** * @brief Set the @c std::string for the implementation to create the states @@ -3503,7 +3503,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface to create the constants array. */ - std::string interfaceCreateConstantsArrayMethodString() const; + const std::string &interfaceCreateConstantsArrayMethodString() const; /** * @brief Set the @c std::string for the interface to create the constants @@ -3526,7 +3526,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation to create the constants * array. */ - std::string implementationCreateConstantsArrayMethodString() const; + const std::string &implementationCreateConstantsArrayMethodString() const; /** * @brief Set the @c std::string for the implementation to create the constants @@ -3547,7 +3547,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface to create the computed constants array. */ - std::string interfaceCreateComputedConstantsArrayMethodString() const; + const std::string &interfaceCreateComputedConstantsArrayMethodString() const; /** * @brief Set the @c std::string for the interface to create the computed constants @@ -3570,7 +3570,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation to create the computed constants * array. */ - std::string implementationCreateComputedConstantsArrayMethodString() const; + const std::string &implementationCreateComputedConstantsArrayMethodString() const; /** * @brief Set the @c std::string for the implementation to create the computed constants @@ -3591,7 +3591,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface to create the algebraic variables array. */ - std::string interfaceCreateAlgebraicVariablesArrayMethodString() const; + const std::string &interfaceCreateAlgebraicVariablesArrayMethodString() const; /** * @brief Set the @c std::string for the interface to create the algebraic variables @@ -3614,7 +3614,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation to create the algebraic variables * array. */ - std::string implementationCreateAlgebraicVariablesArrayMethodString() const; + const std::string &implementationCreateAlgebraicVariablesArrayMethodString() const; /** * @brief Set the @c std::string for the implementation to create the algebraic variables @@ -3635,7 +3635,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface to create the external variables array. */ - std::string interfaceCreateExternalVariablesArrayMethodString() const; + const std::string &interfaceCreateExternalVariablesArrayMethodString() const; /** * @brief Set the @c std::string for the interface to create the external variables @@ -3658,7 +3658,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation to create the external variables * array. */ - std::string implementationCreateExternalVariablesArrayMethodString() const; + const std::string &implementationCreateExternalVariablesArrayMethodString() const; /** * @brief Set the @c std::string for the implementation to create the external variables @@ -3678,7 +3678,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface to delete an array. */ - std::string interfaceDeleteArrayMethodString() const; + const std::string &interfaceDeleteArrayMethodString() const; /** * @brief Set the @c std::string for the interface to delete an array. @@ -3697,7 +3697,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the implementation to delete an array. */ - std::string implementationDeleteArrayMethodString() const; + const std::string &implementationDeleteArrayMethodString() const; /** * @brief Set the @c std::string for the implementation to delete an array. @@ -3719,7 +3719,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface to initialise variables. */ - std::string interfaceInitialiseArraysMethodString(bool forDifferentialModel) const; + const std::string &interfaceInitialiseArraysMethodString(bool forDifferentialModel) const; /** * @brief Set the @c std::string for the interface to initialise variables. @@ -3746,7 +3746,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation to initialise * variables. */ - std::string implementationInitialiseArraysMethodString(bool forDifferentialModel) const; + const std::string &implementationInitialiseArraysMethodString(bool forDifferentialModel) const; /** * @brief Set the @c std::string for the implementation to initialise @@ -3777,7 +3777,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the interface to compute computed * constants. */ - std::string interfaceComputeComputedConstantsMethodString(bool forDifferentialModel) const; + const std::string &interfaceComputeComputedConstantsMethodString(bool forDifferentialModel) const; /** * @brief Set the @c std::string for the interface to compute computed @@ -3806,7 +3806,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation to compute computed * constants. */ - std::string implementationComputeComputedConstantsMethodString(bool forDifferentialModel) const; + const std::string &implementationComputeComputedConstantsMethodString(bool forDifferentialModel) const; /** * @brief Set the @c std::string for the implementation to compute computed @@ -3835,7 +3835,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface to compute rates. */ - std::string interfaceComputeRatesMethodString(bool withExternalVariables) const; + const std::string &interfaceComputeRatesMethodString(bool withExternalVariables) const; /** * @brief Set the @c std::string for the interface to compute rates. @@ -3860,7 +3860,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the implementation to compute rates. */ - std::string implementationComputeRatesMethodString(bool withExternalVariables) const; + const std::string &implementationComputeRatesMethodString(bool withExternalVariables) const; /** * @brief Set the @c std::string for the implementation to compute rates. @@ -3889,8 +3889,8 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface to compute variables. */ - std::string interfaceComputeVariablesMethodString(bool forDifferentialModel, - bool withExternalVariables) const; + const std::string &interfaceComputeVariablesMethodString(bool forDifferentialModel, + bool withExternalVariables) const; /** * @brief Set the @c std::string for the interface to compute variables. @@ -3921,8 +3921,8 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the implementation to compute variables. */ - std::string implementationComputeVariablesMethodString(bool forDifferentialModel, - bool withExternalVariables) const; + const std::string &implementationComputeVariablesMethodString(bool forDifferentialModel, + bool withExternalVariables) const; /** * @brief Set the @c std::string for the implementation to compute @@ -3950,7 +3950,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for an empty method. */ - std::string emptyMethodString() const; + const std::string &emptyMethodString() const; /** * @brief Set the @c std::string for an empty method. @@ -3968,7 +3968,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for an indent. */ - std::string indentString() const; + const std::string &indentString() const; /** * @brief Set the @c std::string for an indent. @@ -3986,7 +3986,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for declaring a variable. */ - std::string variableDeclarationString() const; + const std::string &variableDeclarationString() const; /** * @brief Set the @c std::string for declaring a variable. @@ -4005,7 +4005,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for opening an array. */ - std::string openArrayString() const; + const std::string &openArrayString() const; /** * @brief Set the @c std::string for opening an array. @@ -4023,7 +4023,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for closing an array. */ - std::string closeArrayString() const; + const std::string &closeArrayString() const; /** * @brief Set the @c std::string for closing an array. @@ -4041,7 +4041,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for separating elements in an array. */ - std::string arrayElementSeparatorString() const; + const std::string &arrayElementSeparatorString() const; /** * @brief Set the @c std::string for separating elements in an array. @@ -4060,7 +4060,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for a command separator. */ - std::string commandSeparatorString() const; + const std::string &commandSeparatorString() const; /** * @brief Set the @c std::string for a command separator. diff --git a/src/api/libcellml/importedentity.h b/src/api/libcellml/importedentity.h index caecef13a9..7ca3cb1b2e 100644 --- a/src/api/libcellml/importedentity.h +++ b/src/api/libcellml/importedentity.h @@ -79,7 +79,7 @@ class LIBCELLML_EXPORT ImportedEntity * @return The reference to the entity in the imported model, the empty * string if it is not set. */ - std::string importReference() const; + const std::string &importReference() const; /** * @brief Set the import reference. diff --git a/src/api/libcellml/importsource.h b/src/api/libcellml/importsource.h index 16fdb9f849..180cb88a8f 100644 --- a/src/api/libcellml/importsource.h +++ b/src/api/libcellml/importsource.h @@ -65,7 +65,7 @@ class LIBCELLML_EXPORT ImportSource: public Entity * * @return The URL of the source @ref Model if set otherwise the empty string. */ - std::string url() const; + const std::string &url() const; /** * @brief Set the source @ref Model's URL. diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 51d5bf41f1..033c9ab14a 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -238,7 +238,7 @@ class LIBCELLML_EXPORT Issue * * @return The @c std::string description of the issue. */ - std::string description() const; + const std::string &description() const; /** * @brief Get the level of this issue. diff --git a/src/api/libcellml/namedentity.h b/src/api/libcellml/namedentity.h index 21ab58c895..c1f5cdbb80 100644 --- a/src/api/libcellml/namedentity.h +++ b/src/api/libcellml/namedentity.h @@ -54,7 +54,7 @@ class LIBCELLML_EXPORT NamedEntity: public ParentedEntity * * @return @c std::string representation of the Entity name. */ - std::string name() const; + const std::string &name() const; /** * @brief Remove the name of the Entity. diff --git a/src/api/libcellml/reset.h b/src/api/libcellml/reset.h index 04d2a87032..14cdd4c6f3 100644 --- a/src/api/libcellml/reset.h +++ b/src/api/libcellml/reset.h @@ -147,7 +147,7 @@ class LIBCELLML_EXPORT Reset: public ParentedEntity * * @return @c std::string test value for this reset. */ - std::string testValue() const; + const std::string &testValue() const; /** * @brief Set the test value string for this reset. @@ -194,7 +194,7 @@ class LIBCELLML_EXPORT Reset: public ParentedEntity * * @return @c std::string The identifier of the test value for this reset. */ - std::string testValueId() const; + const std::string &testValueId() const; /** * @brief Append the argument to the reset value for this reset. @@ -213,7 +213,7 @@ class LIBCELLML_EXPORT Reset: public ParentedEntity * * @return @c std::string reset value for this reset. */ - std::string resetValue() const; + const std::string &resetValue() const; /** * @brief Set the reset value math for this reset. @@ -259,7 +259,7 @@ class LIBCELLML_EXPORT Reset: public ParentedEntity * * @return @c std::string The identifier of the reset value for this reset. */ - std::string resetValueId() const; + const std::string &resetValueId() const; /** * @brief Create a clone of this reset. diff --git a/src/api/libcellml/variable.h b/src/api/libcellml/variable.h index 5bfa4630c9..fe4cbbc72c 100644 --- a/src/api/libcellml/variable.h +++ b/src/api/libcellml/variable.h @@ -371,7 +371,7 @@ class LIBCELLML_EXPORT Variable: public NamedEntity * * @return the initial value as a @c std::string. */ - std::string initialValue() const; + const std::string &initialValue() const; /** * @brief Clear the initial value for this variable. @@ -414,7 +414,7 @@ class LIBCELLML_EXPORT Variable: public NamedEntity * * @return the interface type as a @c std::string. */ - std::string interfaceType() const; + const std::string &interfaceType() const; /** * @brief Clear the interface type for this variable. diff --git a/src/bindings/interface/analyserequationast.i b/src/bindings/interface/analyserequationast.i index d8d42695f6..bf38f5c5f2 100644 --- a/src/bindings/interface/analyserequationast.i +++ b/src/bindings/interface/analyserequationast.i @@ -49,6 +49,9 @@ %feature("docstring") libcellml::AnalyserEquationAst::setRightChild "Sets the :class:`AnalyserEquationAst` right child for this :class:`AnalyserEquationAst` object."; +%feature("docstring") libcellml::AnalyserEquationAst::clone +"Create a copy of this :class:`AnalyserEquationAst` object."; + %feature("docstring") libcellml::AnalyserEquationAst::swapLeftAndRightChildren "Swaps the left and right children of this :class:`AnalyserEquationAst` object."; @@ -67,3 +70,10 @@ %include "libcellml/types.h" %include "libcellml/analyserequationast.h" + +%pythoncode %{ +def _analyserequationast_clone(self, parentAst=None): + r"""Create a copy of this :class:`AnalyserEquationAst` object.""" + return _analyserequationast.AnalyserEquationAst_clone(self, parentAst) +AnalyserEquationAst.clone = _analyserequationast_clone +%} diff --git a/src/bindings/javascript/analyserequationast.cpp b/src/bindings/javascript/analyserequationast.cpp index 00d53dbf99..15c693d7f6 100644 --- a/src/bindings/javascript/analyserequationast.cpp +++ b/src/bindings/javascript/analyserequationast.cpp @@ -106,6 +106,12 @@ EMSCRIPTEN_BINDINGS(libcellml_analyserequationast) .function("setLeftChild", &libcellml::AnalyserEquationAst::setLeftChild) .function("rightChild", &libcellml::AnalyserEquationAst::rightChild) .function("setRightChild", &libcellml::AnalyserEquationAst::setRightChild) + .function("clone", emscripten::optional_override([](libcellml::AnalyserEquationAst &self) { + return self.clone(); + })) + .function("clone", emscripten::optional_override([](libcellml::AnalyserEquationAst &self, const libcellml::AnalyserEquationAstPtr &parentAst) { + return self.clone(parentAst); + })) .function("swapLeftAndRightChildren", &libcellml::AnalyserEquationAst::swapLeftAndRightChildren) ; diff --git a/src/bindings/python/CMakeLists.txt b/src/bindings/python/CMakeLists.txt index d4f702aa58..dac5779c3d 100644 --- a/src/bindings/python/CMakeLists.txt +++ b/src/bindings/python/CMakeLists.txt @@ -77,10 +77,14 @@ endif() if(MSVC) get_runtime_dlls_from_target(${LIBXML2_TARGET} TARGET_FILE LIBXML2_DLLS) get_runtime_dlls_from_target(${LIBXML2_TARGET} TARGET_FILE_NAME LIBXML2_DLL_NAMES) + get_runtime_dlls_from_target(${SYMENGINE_TARGET} TARGET_FILE SYMENGINE_DLLS) + get_runtime_dlls_from_target(${SYMENGINE_TARGET} TARGET_FILE_NAME SYMENGINE_DLL_NAMES) get_runtime_dlls_from_target(${ZLIB_TARGET} TARGET_FILE ZLIB_DLLS) get_runtime_dlls_from_target(${ZLIB_TARGET} TARGET_FILE_NAME ZLIB_DLL_NAMES) - list(APPEND FINALISE_PYTHON_BINDINGS_ARGUMENTS -DTARGET_FILE_NAME_zlib=${ZLIB_DLL_NAMES}) - list(APPEND FINALISE_PYTHON_BINDINGS_ARGUMENTS -DTARGET_FILE_NAME_libxml2=${LIBXML2_DLL_NAMES}) + get_target_property(SYMENGINE_DLL_LOC ${SYMENGINE_TARGET} IMPORTED_LOCATION_DEBUG) + get_filename_component(SYMENGINE_DLL_DIR "${SYMENGINE_DLL_LOC}" DIRECTORY) + file(GLOB SYMENGINE_TRANSITIVE_DLLS "${SYMENGINE_DLL_DIR}/*.dll") + list(REMOVE_ITEM SYMENGINE_TRANSITIVE_DLLS ${SYMENGINE_DLL_LOC}) endif() set(SWIG_PYTHON_BINDINGS_TARGETS) @@ -137,10 +141,38 @@ foreach(SWIG_INTERFACE_SRC ${SWIG_INTERFACE_SRCS}) else() set(RPATH_ORIGIN "no_rpath") endif() + # Initialise the RPATH list with the origin. + set(RPATH_LIST "${RPATH_ORIGIN}") + # For development builds, add RPATH entries for all shared dependency library directories so that the Python bindings + # can resolve @rpath-based library references (e.g., from GHA-provided dependencies) at runtime. For wheel builds + # (SKBUILD), all dependencies are bundled alongside the bindings so the origin RPATH is sufficient. + if(NOT SKBUILD) + # Resolve each dependency target to a SHARED target usable with $. This handles INTERFACE IMPORTED + # aliases (e.g., ZLIB::ZLIB wrapping zlib) by resolving INTERFACE_LINK_LIBRARIES to find the underlying shared + # library target. + foreach(_rpath_target ${LIBXML2_TARGET} ${SYMENGINE_TARGET} ${ZLIB_TARGET}) + if(TARGET ${_rpath_target}) + get_target_property(_rpath_target_type ${_rpath_target} TYPE) + if(_rpath_target_type STREQUAL "SHARED_LIBRARY") + list(APPEND RPATH_LIST "$") + elseif(_rpath_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_link_libraries ${_rpath_target} INTERFACE_LINK_LIBRARIES) + foreach(_link_library ${_link_libraries}) + if(TARGET ${_link_library}) + get_target_property(_link_type ${_link_library} TYPE) + if(_link_type STREQUAL "SHARED_LIBRARY") + list(APPEND RPATH_LIST "$") + endif() + endif() + endforeach() + endif() + endif() + endforeach() + endif() set_target_properties(${MODULE_TARGET} PROPERTIES CXX_VISIBILITY_PRESET hidden BUILD_WITH_INSTALL_RPATH TRUE - INSTALL_RPATH "${RPATH_ORIGIN}" + INSTALL_RPATH "${RPATH_LIST}" FOLDER bindings/python RUNTIME_OUTPUT_DIRECTORY ${LIBCELLML_PYTHON_PACKAGE_DIR} LIBRARY_OUTPUT_DIRECTORY ${LIBCELLML_PYTHON_PACKAGE_DIR} @@ -169,7 +201,7 @@ set(FINALISE_PYTHON_BINDINGS_SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/finalise_python_ configure_file(${PROJECT_SOURCE_DIR}/cmake/finalise_python_package.in.cmake ${FINALISE_PYTHON_BINDINGS_SCRIPT} @ONLY) add_custom_command(TARGET python_bindings POST_BUILD COMMAND ${CMAKE_COMMAND} ${FINALISE_PYTHON_BINDINGS_ARGUMENTS} -P ${FINALISE_PYTHON_BINDINGS_SCRIPT} - COMMAND ${CMAKE_COMMAND} -E copy_if_different $ ${_GENERATOR_EXPRESSION_LIBCELLML_SONAME} ${LIBXML2_DLLS} ${ZLIB_DLLS} ${LIBCELLML_PYTHON_PACKAGE_DIR} + COMMAND ${CMAKE_COMMAND} -E copy_if_different $ ${_GENERATOR_EXPRESSION_LIBCELLML_SONAME} ${LIBXML2_DLLS} ${ZLIB_DLLS} ${SYMENGINE_DLLS} ${SYMENGINE_TRANSITIVE_DLLS} ${LIBCELLML_PYTHON_PACKAGE_DIR} COMMAND ${CMAKE_COMMAND} -E copy_directory ${_SWIG_GENERATED_PYTHON_FILES_DIR} ${LIBCELLML_PYTHON_PACKAGE_DIR} COMMENT "Finalise preparation of libCellML Python bindings." ) diff --git a/src/commonutils.cpp b/src/commonutils.cpp index 412691ff77..cbb6b04f35 100644 --- a/src/commonutils.cpp +++ b/src/commonutils.cpp @@ -16,6 +16,8 @@ limitations under the License. #include "commonutils.h" +#include + #include "libcellml/component.h" #include "libcellml/model.h" @@ -25,14 +27,16 @@ namespace libcellml { libcellml::ModelPtr owningModel(const libcellml::ParentedEntityConstPtr &entity) { - auto model = std::dynamic_pointer_cast(entity->parent()); - auto component = owningComponent(entity); - while ((model == nullptr) && (component != nullptr)) { - model = std::dynamic_pointer_cast(component->parent()); - component = owningComponent(component); + auto parent = entity->parent(); + while (parent != nullptr) { + auto model = std::dynamic_pointer_cast(parent); + if (model != nullptr) { + return model; + } + parent = parent->parent(); } - return model; + return nullptr; } libcellml::ComponentPtr owningComponent(const libcellml::ParentedEntityConstPtr &entity) @@ -40,6 +44,16 @@ libcellml::ComponentPtr owningComponent(const libcellml::ParentedEntityConstPtr return std::dynamic_pointer_cast(entity->parent()); } +double epsilon() +{ + static const double epsilonValue = 100.0 * std::numeric_limits::epsilon(); + + return epsilonValue; + // Note: ideally, we would be returning std::numeric_limits::epsilon() which is approximately 2.220446e-16, + // but we need to use a slightly larger value to account for the fact that we want to be able to compare + // numbers from SymEngine. +} + #ifndef TEST_UTILS } // namespace libcellml #endif diff --git a/src/commonutils.h b/src/commonutils.h index dc5ad20c00..7069814ee5 100644 --- a/src/commonutils.h +++ b/src/commonutils.h @@ -45,6 +45,13 @@ libcellml::ModelPtr TEST_EXPORT owningModel(const libcellml::ParentedEntityConst */ libcellml::ComponentPtr TEST_EXPORT owningComponent(const libcellml::ParentedEntityConstPtr &entity); +/** + * @brief Get the epsilon value for double precision comparisons. + * + * @return The epsilon value for double precision comparisons. + */ +double TEST_EXPORT epsilon(); + #ifndef TEST_UTILS } // namespace libcellml diff --git a/src/component.cpp b/src/component.cpp index c2c7fe1468..26d7da068f 100644 --- a/src/component.cpp +++ b/src/component.cpp @@ -37,19 +37,19 @@ namespace libcellml { std::vector::const_iterator Component::ComponentImpl::findVariable(const std::string &name) const { return std::find_if(mVariables.begin(), mVariables.end(), - [=](const VariablePtr &v) -> bool { return v->name() == name; }); + [&](const VariablePtr &v) -> bool { return v->name() == name; }); } std::vector::const_iterator Component::ComponentImpl::findVariable(const VariablePtr &variable) const { return std::find_if(mVariables.begin(), mVariables.end(), - [=](const VariablePtr &v) -> bool { return v->equals(variable); }); + [&](const VariablePtr &v) -> bool { return v->equals(variable); }); } std::vector::const_iterator Component::ComponentImpl::findReset(const ResetPtr &reset) const { return std::find_if(mResets.begin(), mResets.end(), - [=](const ResetPtr &r) -> bool { return r->equals(reset); }); + [&](const ResetPtr &r) -> bool { return r->equals(reset); }); } bool Component::ComponentImpl::equalVariables(const ComponentPtr &other) const @@ -188,7 +188,7 @@ void Component::appendMath(const std::string &math) pFunc()->mMath.append(math); } -std::string Component::math() const +const std::string &Component::math() const { return pFunc()->mMath; } diff --git a/src/componententity.cpp b/src/componententity.cpp index de8e28184a..32500d4001 100644 --- a/src/componententity.cpp +++ b/src/componententity.cpp @@ -29,13 +29,13 @@ namespace libcellml { std::vector::const_iterator ComponentEntity::ComponentEntityImpl::findComponent(const std::string &name) const { return std::find_if(mComponents.begin(), mComponents.end(), - [=](const ComponentPtr &c) -> bool { return c->name() == name; }); + [&](const ComponentPtr &c) -> bool { return c->name() == name; }); } std::vector::const_iterator ComponentEntity::ComponentEntityImpl::findComponent(const ComponentPtr &component) const { return std::find_if(mComponents.begin(), mComponents.end(), - [=](const ComponentPtr &c) -> bool { return c->equals(component); }); + [&](const ComponentPtr &c) -> bool { return c->equals(component); }); } ComponentEntity::ComponentEntityImpl *ComponentEntity::pFunc() @@ -260,7 +260,7 @@ void ComponentEntity::setEncapsulationId(const std::string &id) pFunc()->mEncapsulationId = id; } -std::string ComponentEntity::encapsulationId() const +const std::string &ComponentEntity::encapsulationId() const { return pFunc()->mEncapsulationId; } diff --git a/src/entity.cpp b/src/entity.cpp index abd65dd9fa..9226b807c3 100644 --- a/src/entity.cpp +++ b/src/entity.cpp @@ -34,7 +34,7 @@ void Entity::setId(const std::string &id) pFunc()->mId = id; } -std::string Entity::id() const +const std::string &Entity::id() const { return pFunc()->mId; } diff --git a/src/generator.cpp b/src/generator.cpp index 4a4ecc2ec4..ca53a35cbf 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -16,7 +16,10 @@ limitations under the License. #include "libcellml/generator.h" -#include +#include +#include +#include +#include #include "libcellml/analyserequation.h" #include "libcellml/analyserequationast.h" @@ -42,12 +45,109 @@ void Generator::GeneratorImpl::reset() mCode = {}; } +void Generator::GeneratorImpl::initProfileCache() +{ + // Boolean operator flags. + + mProfileCache.hasEqOperator = mProfile->hasEqOperator(); + mProfileCache.hasNeqOperator = mProfile->hasNeqOperator(); + mProfileCache.hasLtOperator = mProfile->hasLtOperator(); + mProfileCache.hasLeqOperator = mProfile->hasLeqOperator(); + mProfileCache.hasGtOperator = mProfile->hasGtOperator(); + mProfileCache.hasGeqOperator = mProfile->hasGeqOperator(); + mProfileCache.hasAndOperator = mProfile->hasAndOperator(); + mProfileCache.hasOrOperator = mProfile->hasOrOperator(); + mProfileCache.hasXorOperator = mProfile->hasXorOperator(); + mProfileCache.hasNotOperator = mProfile->hasNotOperator(); + mProfileCache.hasPowerOperator = mProfile->hasPowerOperator(); + mProfileCache.hasConditionalOperator = mProfile->hasConditionalOperator(); + + // Hot-path strings. + + mProfileCache.equalityString = mProfile->equalityString(); + mProfileCache.eqString = mProfile->eqString(); + mProfileCache.neqString = mProfile->neqString(); + mProfileCache.ltString = mProfile->ltString(); + mProfileCache.leqString = mProfile->leqString(); + mProfileCache.gtString = mProfile->gtString(); + mProfileCache.geqString = mProfile->geqString(); + mProfileCache.andString = mProfile->andString(); + mProfileCache.orString = mProfile->orString(); + mProfileCache.xorString = mProfile->xorString(); + mProfileCache.notString = mProfile->notString(); + mProfileCache.plusString = mProfile->plusString(); + mProfileCache.minusString = mProfile->minusString(); + mProfileCache.timesString = mProfile->timesString(); + mProfileCache.divideString = mProfile->divideString(); + mProfileCache.powerString = mProfile->powerString(); + mProfileCache.squareRootString = mProfile->squareRootString(); + mProfileCache.squareString = mProfile->squareString(); + mProfileCache.absoluteValueString = mProfile->absoluteValueString(); + mProfileCache.exponentialString = mProfile->exponentialString(); + mProfileCache.naturalLogarithmString = mProfile->naturalLogarithmString(); + mProfileCache.commonLogarithmString = mProfile->commonLogarithmString(); + mProfileCache.ceilingString = mProfile->ceilingString(); + mProfileCache.floorString = mProfile->floorString(); + mProfileCache.minString = mProfile->minString(); + mProfileCache.maxString = mProfile->maxString(); + mProfileCache.remString = mProfile->remString(); + mProfileCache.sinString = mProfile->sinString(); + mProfileCache.cosString = mProfile->cosString(); + mProfileCache.tanString = mProfile->tanString(); + mProfileCache.secString = mProfile->secString(); + mProfileCache.cscString = mProfile->cscString(); + mProfileCache.cotString = mProfile->cotString(); + mProfileCache.sinhString = mProfile->sinhString(); + mProfileCache.coshString = mProfile->coshString(); + mProfileCache.tanhString = mProfile->tanhString(); + mProfileCache.sechString = mProfile->sechString(); + mProfileCache.cschString = mProfile->cschString(); + mProfileCache.cothString = mProfile->cothString(); + mProfileCache.asinString = mProfile->asinString(); + mProfileCache.acosString = mProfile->acosString(); + mProfileCache.atanString = mProfile->atanString(); + mProfileCache.asecString = mProfile->asecString(); + mProfileCache.acscString = mProfile->acscString(); + mProfileCache.acotString = mProfile->acotString(); + mProfileCache.asinhString = mProfile->asinhString(); + mProfileCache.acoshString = mProfile->acoshString(); + mProfileCache.atanhString = mProfile->atanhString(); + mProfileCache.asechString = mProfile->asechString(); + mProfileCache.acschString = mProfile->acschString(); + mProfileCache.acothString = mProfile->acothString(); + mProfileCache.trueString = mProfile->trueString(); + mProfileCache.falseString = mProfile->falseString(); + mProfileCache.eString = mProfile->eString(); + mProfileCache.piString = mProfile->piString(); + mProfileCache.infString = mProfile->infString(); + mProfileCache.nanString = mProfile->nanString(); + mProfileCache.indentString = mProfile->indentString(); + mProfileCache.openArrayString = mProfile->openArrayString(); + mProfileCache.closeArrayString = mProfile->closeArrayString(); + mProfileCache.commandSeparatorString = mProfile->commandSeparatorString(); + mProfileCache.arrayElementSeparatorString = mProfile->arrayElementSeparatorString(); + mProfileCache.variableDeclarationString = mProfile->variableDeclarationString(); + mProfileCache.statesArrayString = mProfile->statesArrayString(); + mProfileCache.ratesArrayString = mProfile->ratesArrayString(); + mProfileCache.constantsArrayString = mProfile->constantsArrayString(); + mProfileCache.computedConstantsArrayString = mProfile->computedConstantsArrayString(); + mProfileCache.algebraicVariablesArrayString = mProfile->algebraicVariablesArrayString(); + mProfileCache.externalVariablesArrayString = mProfile->externalVariablesArrayString(); + mProfileCache.voiString = mProfile->voiString(); + mProfileCache.uArrayString = mProfile->uArrayString(); + mProfileCache.fArrayString = mProfile->fArrayString(); + mProfileCache.conditionalOperatorIfString = mProfile->conditionalOperatorIfString(); + mProfileCache.conditionalOperatorElseString = mProfile->conditionalOperatorElseString(); + mProfileCache.piecewiseIfString = mProfile->piecewiseIfString(); + mProfileCache.piecewiseElseString = mProfile->piecewiseElseString(); +} + std::string Generator::GeneratorImpl::analyserVariableIndexString(const AnalyserVariablePtr &analyserVariable) { // Determine the actual index of the analyser variable in the list of analyser variables by accounting for the fact // that some analyser variables may be untracked. - auto analyserVariables = libcellml::analyserVariables(analyserVariable); + const auto &analyserVariables = libcellml::analyserVariables(analyserVariable); if (analyserVariables.empty()) { return convertToString(analyserVariable->index()); @@ -57,7 +157,7 @@ std::string Generator::GeneratorImpl::analyserVariableIndexString(const Analyser size_t res = MAX_SIZE_T; for (;;) { - auto analyserVar = analyserVariables[++i]; + const auto &analyserVar = analyserVariables[++i]; if (isTrackedVariable(analyserVar, true)) { ++res; @@ -73,17 +173,12 @@ std::string Generator::GeneratorImpl::analyserVariableIndexString(const Analyser bool Generator::GeneratorImpl::isTrackedEquation(const AnalyserEquationPtr &analyserEquation, bool tracked) { - AnalyserVariablePtr analyserVariable; - switch (analyserEquation->type()) { + case AnalyserEquation::Type::CONSTANT: case AnalyserEquation::Type::COMPUTED_CONSTANT: - analyserVariable = analyserEquation->computedConstants().front(); - - return isTrackedVariable(analyserVariable, tracked); + return isTrackedVariable(analyserEquation->computedConstants().front(), tracked); case AnalyserEquation::Type::ALGEBRAIC: - analyserVariable = analyserEquation->algebraicVariables().front(); - - return isTrackedVariable(analyserVariable, tracked); + return isTrackedVariable(analyserEquation->algebraicVariables().front(), tracked); default: return true; } @@ -126,34 +221,21 @@ double Generator::GeneratorImpl::scalingFactor(const AnalyserModelPtr &analyserM return Units::scalingFactor(analyserVariable->variable()->units(), variable->units()); } -bool Generator::GeneratorImpl::isNegativeNumber(const AnalyserEquationAstPtr &ast) const -{ - if (ast->type() == AnalyserEquationAst::Type::CN) { - double doubleValue; - - convertToDouble(ast->value(), doubleValue); - - return doubleValue < 0.0; - } - - return false; -} - bool Generator::GeneratorImpl::isRelationalOperator(const AnalyserEquationAstPtr &ast) const { switch (ast->type()) { case AnalyserEquationAst::Type::EQ: - return mProfile->hasEqOperator(); + return mProfileCache.hasEqOperator; case AnalyserEquationAst::Type::NEQ: - return mProfile->hasNeqOperator(); + return mProfileCache.hasNeqOperator; case AnalyserEquationAst::Type::LT: - return mProfile->hasLtOperator(); + return mProfileCache.hasLtOperator; case AnalyserEquationAst::Type::LEQ: - return mProfile->hasLeqOperator(); + return mProfileCache.hasLeqOperator; case AnalyserEquationAst::Type::GT: - return mProfile->hasGtOperator(); + return mProfileCache.hasGtOperator; case AnalyserEquationAst::Type::GEQ: - return mProfile->hasGeqOperator(); + return mProfileCache.hasGeqOperator; default: return false; } @@ -162,19 +244,19 @@ bool Generator::GeneratorImpl::isRelationalOperator(const AnalyserEquationAstPtr bool Generator::GeneratorImpl::isAndOperator(const AnalyserEquationAstPtr &ast) const { return (ast->type() == AnalyserEquationAst::Type::AND) - && mProfile->hasAndOperator(); + && mProfileCache.hasAndOperator; } bool Generator::GeneratorImpl::isOrOperator(const AnalyserEquationAstPtr &ast) const { return (ast->type() == AnalyserEquationAst::Type::OR) - && mProfile->hasOrOperator(); + && mProfileCache.hasOrOperator; } bool Generator::GeneratorImpl::isXorOperator(const AnalyserEquationAstPtr &ast) const { return (ast->type() == AnalyserEquationAst::Type::XOR) - && mProfile->hasXorOperator(); + && mProfileCache.hasXorOperator; } bool Generator::GeneratorImpl::isLogicalOperator(const AnalyserEquationAstPtr &ast) const @@ -209,19 +291,19 @@ bool Generator::GeneratorImpl::isDivideOperator(const AnalyserEquationAstPtr &as bool Generator::GeneratorImpl::isPowerOperator(const AnalyserEquationAstPtr &ast) const { return (ast->type() == AnalyserEquationAst::Type::POWER) - && mProfile->hasPowerOperator(); + && mProfileCache.hasPowerOperator; } bool Generator::GeneratorImpl::isRootOperator(const AnalyserEquationAstPtr &ast) const { return (ast->type() == AnalyserEquationAst::Type::ROOT) - && mProfile->hasPowerOperator(); + && mProfileCache.hasPowerOperator; } bool Generator::GeneratorImpl::isPiecewiseStatement(const AnalyserEquationAstPtr &ast) const { return (ast->type() == AnalyserEquationAst::Type::PIECEWISE) - && mProfile->hasConditionalOperator(); + && mProfileCache.hasConditionalOperator; } void Generator::GeneratorImpl::updateVariableInfoSizes(size_t &componentSize, @@ -249,9 +331,13 @@ bool Generator::GeneratorImpl::modifiedProfile() const sha1(profileContents) != PYTHON_GENERATOR_PROFILE_SHA1; } -std::string Generator::GeneratorImpl::newLineIfNeeded() +void Generator::GeneratorImpl::addCode(const std::string &code) { - return mCode.empty() ? "" : "\n"; + if (!mCode.empty()) { + mCode += '\n'; + } + + mCode += code; } void Generator::GeneratorImpl::addOriginCommentCode() @@ -267,17 +353,15 @@ void Generator::GeneratorImpl::addOriginCommentCode() "Python"; profileInformation += " profile of"; - mCode += newLineIfNeeded() - + replace(mProfile->commentString(), - "[CODE]", replace(replace(mProfile->originCommentString(), "[PROFILE_INFORMATION]", profileInformation), "[LIBCELLML_VERSION]", versionString())); + addCode(replace(mProfile->commentString(), + "[CODE]", replace(replace(mProfile->originCommentString(), "[PROFILE_INFORMATION]", profileInformation), "[LIBCELLML_VERSION]", versionString()))); } } void Generator::GeneratorImpl::addInterfaceHeaderCode() { if (!mProfile->interfaceHeaderString().empty()) { - mCode += newLineIfNeeded() - + mProfile->interfaceHeaderString(); + addCode(mProfile->interfaceHeaderString()); } } @@ -290,9 +374,8 @@ void Generator::GeneratorImpl::addImplementationHeaderCode() if (!mProfile->implementationHeaderString().empty() && ((hasInterfaceFileName && !mProfile->interfaceFileNameString().empty()) || !hasInterfaceFileName)) { - mCode += newLineIfNeeded() - + replace(mProfile->implementationHeaderString(), - "[INTERFACE_FILE_NAME]", mProfile->interfaceFileNameString()); + addCode(replace(mProfile->implementationHeaderString(), + "[INTERFACE_FILE_NAME]", mProfile->interfaceFileNameString())); } } @@ -306,9 +389,47 @@ void Generator::GeneratorImpl::addVersionAndLibcellmlVersionCode(bool interface) code += mProfile->interfaceVersionString(); } else { if (modifiedProfile()) { - static const std::regex regEx("([0-9]+\\.[0-9]+\\.[0-9]+)"); + // Find the semver pattern (X.Y.Z) and append ".post0". + + auto versionString = mProfile->implementationVersionString(); + size_t start = std::string::npos; + + for (size_t i = 0; i < versionString.size(); ++i) { + if (std::isdigit(static_cast(versionString[i]))) { + if (start == std::string::npos) { + start = i; + } + } else if (versionString[i] == '.' && start != std::string::npos) { + // Continue (it's part of the version string). + } else { + if (start != std::string::npos) { + auto candidate = versionString.substr(start, i - start); + + // Check that it has exactly 2 dots (semver X.Y.Z). + + if (std::count(candidate.begin(), candidate.end(), '.') == 2) { + versionString.insert(i, ".post0"); + + break; + } + } + + start = std::string::npos; + } + } + + // If we reached the end of the string and we found a semver pattern, then append ".post0" to the end of + // the string. + + if (start != std::string::npos) { + auto candidate = versionString.substr(start); + + if (std::count(candidate.begin(), candidate.end(), '.') == 2) { + versionString += ".post0"; + } + } - code += std::regex_replace(mProfile->implementationVersionString(), regEx, "$1.post0"); + code += versionString; } else { code += mProfile->implementationVersionString(); } @@ -324,8 +445,7 @@ void Generator::GeneratorImpl::addVersionAndLibcellmlVersionCode(bool interface) } if (!code.empty()) { - mCode += newLineIfNeeded() - + code; + addCode(code); } } @@ -339,7 +459,7 @@ void Generator::GeneratorImpl::addStateAndVariableCountCode(bool interface) code += interface ? mProfile->interfaceStateCountString() : replace(mProfile->implementationStateCountString(), - "[STATE_COUNT]", std::to_string(mAnalyserModel->stateCount())); + "[STATE_COUNT]", std::format("{}", mAnalyserModel->stateCount())); } if ((interface && !mProfile->interfaceConstantCountString().empty()) @@ -347,7 +467,7 @@ void Generator::GeneratorImpl::addStateAndVariableCountCode(bool interface) code += interface ? mProfile->interfaceConstantCountString() : replace(mProfile->implementationConstantCountString(), - "[CONSTANT_COUNT]", std::to_string((mVariableTracker != nullptr) ? mVariableTracker->trackedConstantCount(mAnalyserModel) : mAnalyserModel->constantCount())); + "[CONSTANT_COUNT]", std::format("{}", (mVariableTracker != nullptr) ? mVariableTracker->trackedConstantCount(mAnalyserModel) : mAnalyserModel->constantCount())); } if ((interface && !mProfile->interfaceComputedConstantCountString().empty()) @@ -355,7 +475,7 @@ void Generator::GeneratorImpl::addStateAndVariableCountCode(bool interface) code += interface ? mProfile->interfaceComputedConstantCountString() : replace(mProfile->implementationComputedConstantCountString(), - "[COMPUTED_CONSTANT_COUNT]", std::to_string((mVariableTracker != nullptr) ? mVariableTracker->trackedComputedConstantCount(mAnalyserModel) : mAnalyserModel->computedConstantCount())); + "[COMPUTED_CONSTANT_COUNT]", std::format("{}", (mVariableTracker != nullptr) ? mVariableTracker->trackedComputedConstantCount(mAnalyserModel) : mAnalyserModel->computedConstantCount())); } if ((interface && !mProfile->interfaceAlgebraicVariableCountString().empty()) @@ -363,7 +483,7 @@ void Generator::GeneratorImpl::addStateAndVariableCountCode(bool interface) code += interface ? mProfile->interfaceAlgebraicVariableCountString() : replace(mProfile->implementationAlgebraicVariableCountString(), - "[ALGEBRAIC_VARIABLE_COUNT]", std::to_string((mVariableTracker != nullptr) ? mVariableTracker->trackedAlgebraicVariableCount(mAnalyserModel) : mAnalyserModel->algebraicVariableCount())); + "[ALGEBRAIC_VARIABLE_COUNT]", std::format("{}", (mVariableTracker != nullptr) ? mVariableTracker->trackedAlgebraicVariableCount(mAnalyserModel) : mAnalyserModel->algebraicVariableCount())); } if ((mAnalyserModel->externalVariableCount() != 0) @@ -372,12 +492,11 @@ void Generator::GeneratorImpl::addStateAndVariableCountCode(bool interface) code += interface ? mProfile->interfaceExternalVariableCountString() : replace(mProfile->implementationExternalVariableCountString(), - "[EXTERNAL_VARIABLE_COUNT]", std::to_string(mAnalyserModel->externalVariableCount())); + "[EXTERNAL_VARIABLE_COUNT]", std::format("{}", mAnalyserModel->externalVariableCount())); } if (!code.empty()) { - mCode += newLineIfNeeded() - + code; + addCode(code); } } @@ -394,16 +513,15 @@ std::string Generator::GeneratorImpl::generateVariableInfoObjectCode(const std:: } return replace(replace(replace(objectString, - "[COMPONENT_SIZE]", std::to_string(componentSize)), - "[NAME_SIZE]", std::to_string(nameSize)), - "[UNITS_SIZE]", std::to_string(unitsSize)); + "[COMPONENT_SIZE]", std::format("{}", componentSize)), + "[NAME_SIZE]", std::format("{}", nameSize)), + "[UNITS_SIZE]", std::format("{}", unitsSize)); } void Generator::GeneratorImpl::addVariableInfoObjectCode() { if (!mProfile->variableInfoObjectString().empty()) { - mCode += newLineIfNeeded() - + generateVariableInfoObjectCode(mProfile->variableInfoObjectString()); + addCode(generateVariableInfoObjectCode(mProfile->variableInfoObjectString())); } } @@ -449,8 +567,7 @@ void Generator::GeneratorImpl::addInterfaceVariableInfoCode() } if (!code.empty()) { - mCode += newLineIfNeeded() - + code; + addCode(code); } } @@ -482,8 +599,7 @@ void Generator::GeneratorImpl::addImplementationVariableInfoCode(const std::stri infoElementsCode += "\n"; } - mCode += newLineIfNeeded() - + replace(variableInfoString, "[CODE]", infoElementsCode); + addCode(replace(variableInfoString, "[CODE]", infoElementsCode)); } } @@ -507,74 +623,62 @@ void Generator::GeneratorImpl::addArithmeticFunctionsCode() { if (mAnalyserModel->needEqFunction() && !mProfile->hasEqOperator() && !mProfile->eqFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->eqFunctionString(); + addCode(mProfile->eqFunctionString()); } if (mAnalyserModel->needNeqFunction() && !mProfile->hasNeqOperator() && !mProfile->neqFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->neqFunctionString(); + addCode(mProfile->neqFunctionString()); } if (mAnalyserModel->needLtFunction() && !mProfile->hasLtOperator() && !mProfile->ltFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->ltFunctionString(); + addCode(mProfile->ltFunctionString()); } if (mAnalyserModel->needLeqFunction() && !mProfile->hasLeqOperator() && !mProfile->leqFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->leqFunctionString(); + addCode(mProfile->leqFunctionString()); } if (mAnalyserModel->needGtFunction() && !mProfile->hasGtOperator() && !mProfile->gtFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->gtFunctionString(); + addCode(mProfile->gtFunctionString()); } if (mAnalyserModel->needGeqFunction() && !mProfile->hasGeqOperator() && !mProfile->geqFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->geqFunctionString(); + addCode(mProfile->geqFunctionString()); } if (mAnalyserModel->needAndFunction() && !mProfile->hasAndOperator() && !mProfile->andFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->andFunctionString(); + addCode(mProfile->andFunctionString()); } if (mAnalyserModel->needOrFunction() && !mProfile->hasOrOperator() && !mProfile->orFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->orFunctionString(); + addCode(mProfile->orFunctionString()); } if (mAnalyserModel->needXorFunction() && !mProfile->hasXorOperator() && !mProfile->xorFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->xorFunctionString(); + addCode(mProfile->xorFunctionString()); } if (mAnalyserModel->needNotFunction() && !mProfile->hasNotOperator() && !mProfile->notFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->notFunctionString(); + addCode(mProfile->notFunctionString()); } if (mAnalyserModel->needMinFunction() && !mProfile->minFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->minFunctionString(); + addCode(mProfile->minFunctionString()); } if (mAnalyserModel->needMaxFunction() && !mProfile->maxFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->maxFunctionString(); + addCode(mProfile->maxFunctionString()); } } @@ -582,74 +686,62 @@ void Generator::GeneratorImpl::addTrigonometricFunctionsCode() { if (mAnalyserModel->needSecFunction() && !mProfile->secFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->secFunctionString(); + addCode(mProfile->secFunctionString()); } if (mAnalyserModel->needCscFunction() && !mProfile->cscFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->cscFunctionString(); + addCode(mProfile->cscFunctionString()); } if (mAnalyserModel->needCotFunction() && !mProfile->cotFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->cotFunctionString(); + addCode(mProfile->cotFunctionString()); } if (mAnalyserModel->needSechFunction() && !mProfile->sechFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->sechFunctionString(); + addCode(mProfile->sechFunctionString()); } if (mAnalyserModel->needCschFunction() && !mProfile->cschFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->cschFunctionString(); + addCode(mProfile->cschFunctionString()); } if (mAnalyserModel->needCothFunction() && !mProfile->cothFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->cothFunctionString(); + addCode(mProfile->cothFunctionString()); } if (mAnalyserModel->needAsecFunction() && !mProfile->asecFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->asecFunctionString(); + addCode(mProfile->asecFunctionString()); } if (mAnalyserModel->needAcscFunction() && !mProfile->acscFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->acscFunctionString(); + addCode(mProfile->acscFunctionString()); } if (mAnalyserModel->needAcotFunction() && !mProfile->acotFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->acotFunctionString(); + addCode(mProfile->acotFunctionString()); } if (mAnalyserModel->needAsechFunction() && !mProfile->asechFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->asechFunctionString(); + addCode(mProfile->asechFunctionString()); } if (mAnalyserModel->needAcschFunction() && !mProfile->acschFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->acschFunctionString(); + addCode(mProfile->acschFunctionString()); } if (mAnalyserModel->needAcothFunction() && !mProfile->acothFunctionString().empty()) { - mCode += newLineIfNeeded() - + mProfile->acothFunctionString(); + addCode(mProfile->acothFunctionString()); } } @@ -685,8 +777,7 @@ void Generator::GeneratorImpl::addInterfaceCreateDeleteArrayMethodsCode() } if (!code.empty()) { - mCode += newLineIfNeeded() - + code; + addCode(code); } } @@ -694,45 +785,38 @@ void Generator::GeneratorImpl::addImplementationCreateDeleteArrayMethodsCode() { if (modelHasOdes(mAnalyserModel) && !mProfile->implementationCreateStatesArrayMethodString().empty()) { - mCode += newLineIfNeeded() - + mProfile->implementationCreateStatesArrayMethodString(); + addCode(mProfile->implementationCreateStatesArrayMethodString()); } if (!mProfile->implementationCreateConstantsArrayMethodString().empty()) { - mCode += newLineIfNeeded() - + mProfile->implementationCreateConstantsArrayMethodString(); + addCode(mProfile->implementationCreateConstantsArrayMethodString()); } if (!mProfile->implementationCreateComputedConstantsArrayMethodString().empty()) { - mCode += newLineIfNeeded() - + mProfile->implementationCreateComputedConstantsArrayMethodString(); + addCode(mProfile->implementationCreateComputedConstantsArrayMethodString()); } if (!mProfile->implementationCreateAlgebraicVariablesArrayMethodString().empty()) { - mCode += newLineIfNeeded() - + mProfile->implementationCreateAlgebraicVariablesArrayMethodString(); + addCode(mProfile->implementationCreateAlgebraicVariablesArrayMethodString()); } if (mAnalyserModel->hasExternalVariables() && !mProfile->implementationCreateExternalVariablesArrayMethodString().empty()) { - mCode += newLineIfNeeded() - + mProfile->implementationCreateExternalVariablesArrayMethodString(); + addCode(mProfile->implementationCreateExternalVariablesArrayMethodString()); } if (!mProfile->implementationDeleteArrayMethodString().empty()) { - mCode += newLineIfNeeded() - + mProfile->implementationDeleteArrayMethodString(); + addCode(mProfile->implementationDeleteArrayMethodString()); } } void Generator::GeneratorImpl::addExternalVariableMethodTypeDefinitionCode() { if (mAnalyserModel->hasExternalVariables()) { - auto externalVariableMethodTypeDefinitionString = mProfile->externalVariableMethodTypeDefinitionString(modelHasOdes(mAnalyserModel)); + const auto &externalVariableMethodTypeDefinitionString = mProfile->externalVariableMethodTypeDefinitionString(modelHasOdes(mAnalyserModel)); if (!externalVariableMethodTypeDefinitionString.empty()) { - mCode += newLineIfNeeded() - + externalVariableMethodTypeDefinitionString; + addCode(externalVariableMethodTypeDefinitionString); } } } @@ -740,16 +824,14 @@ void Generator::GeneratorImpl::addExternalVariableMethodTypeDefinitionCode() void Generator::GeneratorImpl::addRootFindingInfoObjectCode() { if (!mProfile->rootFindingInfoObjectString(modelHasOdes(mAnalyserModel), mAnalyserModel->hasExternalVariables()).empty()) { - mCode += newLineIfNeeded() - + mProfile->rootFindingInfoObjectString(modelHasOdes(mAnalyserModel), mAnalyserModel->hasExternalVariables()); + addCode(mProfile->rootFindingInfoObjectString(modelHasOdes(mAnalyserModel), mAnalyserModel->hasExternalVariables())); } } void Generator::GeneratorImpl::addExternNlaSolveMethodCode() { if (!mProfile->externNlaSolveMethodString().empty()) { - mCode += newLineIfNeeded() - + mProfile->externNlaSolveMethodString(); + addCode(mProfile->externNlaSolveMethodString()); } } @@ -758,62 +840,90 @@ void Generator::GeneratorImpl::addNlaSystemsCode() if (!mProfile->objectiveFunctionMethodString(modelHasOdes(mAnalyserModel), mAnalyserModel->hasExternalVariables()).empty() && !mProfile->findRootMethodString(modelHasOdes(mAnalyserModel), mAnalyserModel->hasExternalVariables()).empty() && !mProfile->nlaSolveCallString(modelHasOdes(mAnalyserModel), mAnalyserModel->hasExternalVariables()).empty()) { - // Note: only states and algebraic variables can be computed through an NLA system. Constants, computed - // constants, and external variables cannot, by definition, be computed through an NLA system. + // Note: only algebraic variables can be computed through an NLA system. Constants, computed constants, + // algebraic variables, and external variables cannot, by definition, be computed through an NLA system. - std::vector handledNlaAnalyserEquations; + std::unordered_set handledNlaAnalyserEquations; for (const auto &analyserEquation : mAnalyserModel->analyserEquations()) { if ((analyserEquation->type() == AnalyserEquation::Type::NLA) - && (std::find(handledNlaAnalyserEquations.begin(), handledNlaAnalyserEquations.end(), analyserEquation) == handledNlaAnalyserEquations.end())) { + && (handledNlaAnalyserEquations.find(analyserEquation.get()) == handledNlaAnalyserEquations.end())) { // 1) Generate some code for the objectiveFunction[INDEX]() method. - // a) Retrieve the values from our NLA solver's u array. + // a) Assign the values to our NLA solver's f array for the current equation's algebraic variables + // and collect them in the process. std::string methodBody; auto i = MAX_SIZE_T; auto analyserVariables = libcellml::analyserVariables(analyserEquation); for (const auto &analyserVariable : analyserVariables) { - auto arrayString = (analyserVariable->type() == AnalyserVariable::Type::STATE) ? - mProfile->ratesArrayString() : - mProfile->algebraicVariablesArrayString(); - methodBody += mProfile->indentString() - + arrayString + mProfile->openArrayString() + analyserVariableIndexString(analyserVariable) + mProfile->closeArrayString() + + mProfile->algebraicVariablesArrayString() + mProfile->openArrayString() + analyserVariableIndexString(analyserVariable) + mProfile->closeArrayString() + mProfile->equalityString() + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(++i) + mProfile->closeArrayString() + mProfile->commandSeparatorString() + "\n"; } - // b) Initialise any untracked constant, computed constant, or algebraic variable that is needed by - // our NLA system. + // b) Collect the equations that we need to generate code for. methodBody += "\n"; - auto methodBodySize = methodBody.size(); + std::vector nlaEquations; + const auto &nlaSiblings = analyserEquation->nlaSiblings(); + std::unordered_set seenDependencyEquations; + std::vector collectedDependencies; + + nlaEquations.reserve(1 + nlaSiblings.size()); + + nlaEquations.push_back(analyserEquation); + nlaEquations.insert(nlaEquations.end(), nlaSiblings.begin(), nlaSiblings.end()); - for (const auto &constantDependency : analyserEquation->mPimpl->mConstantDependencies) { - if (isTrackedVariable(constantDependency, false)) { - methodBody += generateInitialisationCode(constantDependency, true); + for (const auto &nlaEquation : nlaEquations) { + for (const auto &constantDependency : nlaEquation->mPimpl->mConstantDependencies) { + if (isTrackedVariable(constantDependency, false)) { + methodBody += generateInitialisationCode(constantDependency, true); + } } - } - std::vector dummyRemainingAnalyserEquations = mAnalyserModel->analyserEquations(); - std::vector dummyAnalyserEquationsForDependencies; - std::vector dummyGeneratedConstantDependencies; - - for (const auto &dependency : analyserEquation->dependencies()) { - if (((dependency->type() == AnalyserEquation::Type::COMPUTED_CONSTANT) - || (dependency->type() == AnalyserEquation::Type::ALGEBRAIC)) - && isTrackedEquation(dependency, false)) { - methodBody += generateEquationCode(dependency, dummyRemainingAnalyserEquations, - dummyAnalyserEquationsForDependencies, - dummyGeneratedConstantDependencies, false, - GenerateEquationCodeTarget::OBJECTIVE_FUNCTION); + for (const auto &dependency : nlaEquation->dependencies()) { + if (((dependency->type() == AnalyserEquation::Type::CONSTANT) + || (dependency->type() == AnalyserEquation::Type::COMPUTED_CONSTANT)) + && isTrackedEquation(dependency, false) + && seenDependencyEquations.insert(dependency.get()).second) { + collectedDependencies.push_back(dependency); + } } } - // c) Generate our NLA system's objective functions. + // c) Sort the collected dependencies according to the order in which they appear in our NLA + // system's dependency graph. + + const auto &analyserEquations = mAnalyserModel->analyserEquations(); + std::unordered_map equationIndices; + + for (size_t j = 0; j < analyserEquations.size(); ++j) { + equationIndices[analyserEquations[j].get()] = j; + } + + std::sort(collectedDependencies.begin(), collectedDependencies.end(), [&equationIndices](const AnalyserEquationPtr &ae1, const AnalyserEquationPtr &ae2) { + return equationIndices.at(ae1.get()) < equationIndices.at(ae2.get()); + }); + + // d) Generate code for the collected dependencies. + + auto methodBodySize = methodBody.size(); + std::unordered_set dummyRemainingAnalyserEquations(analyserEquations.begin(), analyserEquations.end()); + std::unordered_set dummyAnalyserEquationsForDependencies; + std::unordered_set dummyGeneratedConstantDependencies; + + for (const auto &dependency : collectedDependencies) { + methodBody += generateEquationCode(dependency, dummyRemainingAnalyserEquations, + dummyAnalyserEquationsForDependencies, + dummyGeneratedConstantDependencies, false, + GenerateEquationCodeTarget::OBJECTIVE_FUNCTION); + } + + // e) Generate code for the current equation and any of its NLA siblings. methodBody += (methodBody.size() == methodBodySize) ? "" : "\n"; @@ -825,7 +935,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() + generateCode(analyserEquation->ast()) + mProfile->commandSeparatorString() + "\n"; - handledNlaAnalyserEquations.push_back(analyserEquation); + handledNlaAnalyserEquations.insert(analyserEquation.get()); for (const auto &nlaSibling : analyserEquation->nlaSiblings()) { methodBody += mProfile->indentString() @@ -834,13 +944,12 @@ void Generator::GeneratorImpl::addNlaSystemsCode() + generateCode(nlaSibling->ast()) + mProfile->commandSeparatorString() + "\n"; - handledNlaAnalyserEquations.push_back(nlaSibling); + handledNlaAnalyserEquations.insert(nlaSibling.get()); } - mCode += newLineIfNeeded() - + replace(replace(mProfile->objectiveFunctionMethodString(modelHasOdes(mAnalyserModel), mAnalyserModel->hasExternalVariables()), - "[INDEX]", convertToString(analyserEquation->nlaSystemIndex())), - "[CODE]", generateMethodBodyCode(methodBody)); + addCode(replace(replace(mProfile->objectiveFunctionMethodString(modelHasOdes(mAnalyserModel), mAnalyserModel->hasExternalVariables()), + "[INDEX]", convertToString(analyserEquation->nlaSystemIndex())), + "[CODE]", generateMethodBodyCode(methodBody))); // 2) Generate some code for the findRoot[INDEX]() method. // a) Assign the values to our NLA solver's u array. @@ -850,14 +959,10 @@ void Generator::GeneratorImpl::addNlaSystemsCode() i = MAX_SIZE_T; for (const auto &analyserVariable : analyserVariables) { - auto arrayString = (analyserVariable->type() == AnalyserVariable::Type::STATE) ? - mProfile->ratesArrayString() : - mProfile->algebraicVariablesArrayString(); - methodBody += mProfile->indentString() + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(++i) + mProfile->closeArrayString() + mProfile->equalityString() - + arrayString + mProfile->openArrayString() + analyserVariableIndexString(analyserVariable) + mProfile->closeArrayString() + + mProfile->algebraicVariablesArrayString() + mProfile->openArrayString() + analyserVariableIndexString(analyserVariable) + mProfile->closeArrayString() + mProfile->commandSeparatorString() + "\n"; } @@ -878,22 +983,17 @@ void Generator::GeneratorImpl::addNlaSystemsCode() methodBody += "\n"; for (const auto &analyserVariable : analyserVariables) { - auto arrayString = (analyserVariable->type() == AnalyserVariable::Type::STATE) ? - mProfile->ratesArrayString() : - mProfile->algebraicVariablesArrayString(); - methodBody += mProfile->indentString() - + arrayString + mProfile->openArrayString() + analyserVariableIndexString(analyserVariable) + mProfile->closeArrayString() + + mProfile->algebraicVariablesArrayString() + mProfile->openArrayString() + analyserVariableIndexString(analyserVariable) + mProfile->closeArrayString() + mProfile->equalityString() + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(++i) + mProfile->closeArrayString() + mProfile->commandSeparatorString() + "\n"; } - mCode += newLineIfNeeded() - + replace(replace(replace(mProfile->findRootMethodString(modelHasOdes(mAnalyserModel), mAnalyserModel->hasExternalVariables()), - "[INDEX]", convertToString(analyserEquation->nlaSystemIndex())), - "[SIZE]", convertToString(analyserVariablesCount)), - "[CODE]", generateMethodBodyCode(methodBody)); + addCode(replace(replace(replace(mProfile->findRootMethodString(modelHasOdes(mAnalyserModel), mAnalyserModel->hasExternalVariables()), + "[INDEX]", convertToString(analyserEquation->nlaSystemIndex())), + "[SIZE]", convertToString(analyserVariablesCount)), + "[CODE]", generateMethodBodyCode(methodBody))); } } } @@ -935,24 +1035,20 @@ std::string Generator::GeneratorImpl::generateDoubleOrVariableNameCode(const Var switch (initialValueAnalyserVariable->type()) { case AnalyserVariable::Type::STATE: - arrayName = mProfile->statesArrayString(); + arrayName = mProfileCache.statesArrayString; break; case AnalyserVariable::Type::CONSTANT: - arrayName = mProfile->constantsArrayString(); + arrayName = mProfileCache.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(); + default: // If it is not one of the above types then it has to be a computed constant. + arrayName = mProfileCache.computedConstantsArrayString; break; } - return arrayName + mProfile->openArrayString() + analyserVariableIndexString(initialValueAnalyserVariable) + mProfile->closeArrayString(); + return arrayName + mProfileCache.openArrayString + analyserVariableIndexString(initialValueAnalyserVariable) + mProfileCache.closeArrayString; } std::string Generator::GeneratorImpl::generateVariableNameCode(const VariablePtr &variable, bool state) @@ -968,37 +1064,47 @@ std::string Generator::GeneratorImpl::generateVariableNameCode(const VariablePtr auto analyserVariable = mAnalyserModel->analyserVariable(variable); if (analyserVariable->type() == AnalyserVariable::Type::VARIABLE_OF_INTEGRATION) { - return mProfile->voiString(); + // Convert the VOI to the units expected by the original variable when the variable is equivalent to the VOI but + // uses different units. + + auto scalingFactor = Units::scalingFactor(variable->units(), analyserVariable->variable()->units()); + + if (!areNearlyEqual(scalingFactor, 1.0)) { + return generateDoubleCode(convertToString(scalingFactor)) + mProfileCache.timesString + mProfileCache.voiString; + } + + return mProfileCache.voiString; } if (isTrackedVariable(analyserVariable, false)) { - return owningComponent(analyserVariable->variable())->name() + "_" + analyserVariable->variable()->name(); + const auto &var = analyserVariable->variable(); + + return owningComponent(var)->name() + "_" + var->name(); } std::string arrayName; if (analyserVariable->type() == AnalyserVariable::Type::STATE) { arrayName = state ? - mProfile->statesArrayString() : - mProfile->ratesArrayString(); + mProfileCache.statesArrayString : + mProfileCache.ratesArrayString; } else if (analyserVariable->type() == AnalyserVariable::Type::CONSTANT) { - arrayName = mProfile->constantsArrayString(); + arrayName = mProfileCache.constantsArrayString; } else if (analyserVariable->type() == AnalyserVariable::Type::COMPUTED_CONSTANT) { - arrayName = mProfile->computedConstantsArrayString(); + arrayName = mProfileCache.computedConstantsArrayString; } else if (analyserVariable->type() == AnalyserVariable::Type::ALGEBRAIC_VARIABLE) { - arrayName = mProfile->algebraicVariablesArrayString(); + arrayName = mProfileCache.algebraicVariablesArrayString; } else { - arrayName = mProfile->externalVariablesArrayString(); + arrayName = mProfileCache.externalVariablesArrayString; } - return arrayName + mProfile->openArrayString() + analyserVariableIndexString(analyserVariable) + mProfile->closeArrayString(); + return arrayName + mProfileCache.openArrayString + analyserVariableIndexString(analyserVariable) + mProfileCache.closeArrayString; } std::string Generator::GeneratorImpl::generateOperatorCode(const std::string &op, const AnalyserEquationAstPtr &ast) { // Generate the code for the left and right branches of the given AST. - std::string res; auto astLeftChild = ast->leftChild(); auto astRightChild = ast->rightChild(); auto astLeftChildCode = generateCode(astLeftChild); @@ -1020,68 +1126,75 @@ std::string Generator::GeneratorImpl::generateOperatorCode(const std::string &op // 10. OR (logical) [Left to right] // 11. PIECEWISE (as an operator) [Right to left] + auto realOp = op; + if (isPlusOperator(ast)) { if (isRelationalOperator(astLeftChild) || isLogicalOperator(astLeftChild) || isPiecewiseStatement(astLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } if (isRelationalOperator(astRightChild) || isLogicalOperator(astRightChild) || isPiecewiseStatement(astRightChild)) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; + } + + // a + -b -> a - b. + + if (astRightChildCode.rfind(mProfile->minusString(), 0) == 0) { + astRightChildCode.erase(0, mProfile->minusString().size()); + + realOp = mProfile->minusString(); } } else if (isMinusOperator(ast)) { if (isRelationalOperator(astLeftChild) || isLogicalOperator(astLeftChild) || isPiecewiseStatement(astLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } - if (isNegativeNumber(astRightChild) - || isRelationalOperator(astRightChild) + if (isRelationalOperator(astRightChild) || isLogicalOperator(astRightChild) || isMinusOperator(astRightChild) || isPiecewiseStatement(astRightChild) - || (astRightChildCode.rfind(mProfile->minusString(), 0) == 0)) { - astRightChildCode = "(" + astRightChildCode + ")"; + || (astRightChildCode.rfind(mProfileCache.minusString, 0) == 0)) { + astRightChildCode = '(' + astRightChildCode + ')'; } else if (isPlusOperator(astRightChild)) { - if (astRightChild->rightChild() != nullptr) { - astRightChildCode = "(" + astRightChildCode + ")"; - } + astRightChildCode = '(' + astRightChildCode + ')'; } } else if (isTimesOperator(ast)) { if (isRelationalOperator(astLeftChild) || isLogicalOperator(astLeftChild) || isPiecewiseStatement(astLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } else if (isPlusOperator(astLeftChild) || isMinusOperator(astLeftChild)) { if (astLeftChild->rightChild() != nullptr) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } } if (isRelationalOperator(astRightChild) || isLogicalOperator(astRightChild) || isPiecewiseStatement(astRightChild)) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } else if (isPlusOperator(astRightChild) || isMinusOperator(astRightChild)) { if (astRightChild->rightChild() != nullptr) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } } } else if (isDivideOperator(ast)) { if (isRelationalOperator(astLeftChild) || isLogicalOperator(astLeftChild) || isPiecewiseStatement(astLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } else if (isPlusOperator(astLeftChild) || isMinusOperator(astLeftChild)) { if (astLeftChild->rightChild() != nullptr) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } } @@ -1090,11 +1203,11 @@ std::string Generator::GeneratorImpl::generateOperatorCode(const std::string &op || isTimesOperator(astRightChild) || isDivideOperator(astRightChild) || isPiecewiseStatement(astRightChild)) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } else if (isPlusOperator(astRightChild) || isMinusOperator(astRightChild)) { if (astRightChild->rightChild() != nullptr) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } } } else if (isAndOperator(ast)) { @@ -1107,32 +1220,32 @@ std::string Generator::GeneratorImpl::generateOperatorCode(const std::string &op || isOrOperator(astLeftChild) || isXorOperator(astLeftChild) || isPiecewiseStatement(astLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } else if (isPlusOperator(astLeftChild) || isMinusOperator(astLeftChild)) { if (astLeftChild->rightChild() != nullptr) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } } else if (isPowerOperator(astLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } else if (isRootOperator(astLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } if (isRelationalOperator(astRightChild) || isOrOperator(astRightChild) || isXorOperator(astRightChild) || isPiecewiseStatement(astRightChild)) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } else if (isPlusOperator(astRightChild) || isMinusOperator(astRightChild)) { if (astRightChild->rightChild() != nullptr) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } } else if (isPowerOperator(astRightChild)) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } else if (isRootOperator(astRightChild)) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } } else if (isOrOperator(ast)) { // Note: according to the precedence rules above, we only need to @@ -1144,32 +1257,32 @@ std::string Generator::GeneratorImpl::generateOperatorCode(const std::string &op || isAndOperator(astLeftChild) || isXorOperator(astLeftChild) || isPiecewiseStatement(astLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } else if (isPlusOperator(astLeftChild) || isMinusOperator(astLeftChild)) { if (astLeftChild->rightChild() != nullptr) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } } else if (isPowerOperator(astLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } else if (isRootOperator(astLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } if (isRelationalOperator(astRightChild) || isAndOperator(astRightChild) || isXorOperator(astRightChild) || isPiecewiseStatement(astRightChild)) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } else if (isPlusOperator(astRightChild) || isMinusOperator(astRightChild)) { if (astRightChild->rightChild() != nullptr) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } } else if (isPowerOperator(astRightChild)) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } else if (isRootOperator(astRightChild)) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } } else if (isXorOperator(ast)) { // Note: according to the precedence rules above, we only need to @@ -1181,32 +1294,32 @@ std::string Generator::GeneratorImpl::generateOperatorCode(const std::string &op || isAndOperator(astLeftChild) || isOrOperator(astLeftChild) || isPiecewiseStatement(astLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } else if (isPlusOperator(astLeftChild) || isMinusOperator(astLeftChild)) { if (astLeftChild->rightChild() != nullptr) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } } else if (isPowerOperator(astLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } else if (isRootOperator(astLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } if (isRelationalOperator(astRightChild) || isAndOperator(astRightChild) || isOrOperator(astRightChild) || isPiecewiseStatement(astRightChild)) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } else if (isPlusOperator(astRightChild) || isMinusOperator(astRightChild)) { if (astRightChild->rightChild() != nullptr) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } } else if (isPowerOperator(astRightChild)) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } else if (isRootOperator(astRightChild)) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } } else if (isPowerOperator(ast)) { if (isRelationalOperator(astLeftChild) @@ -1215,11 +1328,9 @@ std::string Generator::GeneratorImpl::generateOperatorCode(const std::string &op || isTimesOperator(astLeftChild) || isDivideOperator(astLeftChild) || isPiecewiseStatement(astLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } else if (isPlusOperator(astLeftChild)) { - if (astLeftChild->rightChild() != nullptr) { - astLeftChildCode = "(" + astLeftChildCode + ")"; - } + astLeftChildCode = '(' + astLeftChildCode + ')'; } if (isRelationalOperator(astRightChild) @@ -1230,11 +1341,9 @@ std::string Generator::GeneratorImpl::generateOperatorCode(const std::string &op || isPowerOperator(astRightChild) || isRootOperator(astRightChild) || isPiecewiseStatement(astRightChild)) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } else if (isPlusOperator(astRightChild)) { - if (astRightChild->rightChild() != nullptr) { - astRightChildCode = "(" + astRightChildCode + ")"; - } + astRightChildCode = '(' + astRightChildCode + ')'; } } else if (isRootOperator(ast)) { if (isRelationalOperator(astRightChild) @@ -1243,11 +1352,9 @@ std::string Generator::GeneratorImpl::generateOperatorCode(const std::string &op || isTimesOperator(astRightChild) || isDivideOperator(astRightChild) || isPiecewiseStatement(astRightChild)) { - astRightChildCode = "(" + astRightChildCode + ")"; + astRightChildCode = '(' + astRightChildCode + ')'; } else if (isPlusOperator(astRightChild)) { - if (astRightChild->rightChild() != nullptr) { - astRightChildCode = "(" + astRightChildCode + ")"; - } + astRightChildCode = '(' + astRightChildCode + ')'; } auto astLeftChildLeftChild = astLeftChild->leftChild(); @@ -1260,17 +1367,29 @@ std::string Generator::GeneratorImpl::generateOperatorCode(const std::string &op || isPowerOperator(astLeftChildLeftChild) || isRootOperator(astLeftChildLeftChild) || isPiecewiseStatement(astLeftChildLeftChild)) { - astLeftChildCode = "(" + astLeftChildCode + ")"; + astLeftChildCode = '(' + astLeftChildCode + ')'; } else if (isPlusOperator(astLeftChildLeftChild)) { - if (astLeftChildLeftChild->rightChild() != nullptr) { - astLeftChildCode = "(" + astLeftChildCode + ")"; - } + astLeftChildCode = '(' + astLeftChildCode + ')'; } - return astRightChildCode + op + "(1.0/" + astLeftChildCode + ")"; + std::string res; + + res += astRightChildCode; + res += realOp; + res += "(1.0/"; + res += astLeftChildCode; + res += ")"; + + return res; } - return astLeftChildCode + op + astRightChildCode; + std::string res; + + res += astLeftChildCode; + res += realOp; + res += astRightChildCode; + + return res; } std::string Generator::GeneratorImpl::generateMinusUnaryCode(const AnalyserEquationAstPtr &ast) @@ -1287,39 +1406,64 @@ std::string Generator::GeneratorImpl::generateMinusUnaryCode(const AnalyserEquat || isPlusOperator(astLeftChild) || isMinusOperator(astLeftChild) || isPiecewiseStatement(astLeftChild)) { - code = "(" + code + ")"; + code = '(' + code + ')'; } - return mProfile->minusString() + code; + const auto &minusStr = mProfileCache.minusString; + std::string res; + + res += minusStr; + res += code; + + return res; } std::string Generator::GeneratorImpl::generateOneParameterFunctionCode(const std::string &function, const AnalyserEquationAstPtr &ast) { - return function + "(" + generateCode(ast->leftChild()) + ")"; + auto leftChildString = generateCode(ast->leftChild()); + std::string res; + + res += function; + res += '('; + res += leftChildString; + res += ')'; + + return res; } std::string Generator::GeneratorImpl::generateTwoParameterFunctionCode(const std::string &function, const AnalyserEquationAstPtr &ast) { - return function + "(" + generateCode(ast->leftChild()) + ", " + generateCode(ast->rightChild()) + ")"; + auto leftChildString = generateCode(ast->leftChild()); + auto rightChildString = generateCode(ast->rightChild()); + std::string res; + + res += function; + res += '('; + res += leftChildString; + res += ", "; + res += rightChildString; + res += ')'; + + return res; } std::string Generator::GeneratorImpl::generatePiecewiseIfCode(const std::string &condition, const std::string &value) const { - return replace(replace(mProfile->hasConditionalOperator() ? - mProfile->conditionalOperatorIfString() : - mProfile->piecewiseIfString(), + return replace(replace(mProfileCache.hasConditionalOperator ? + mProfileCache.conditionalOperatorIfString : + mProfileCache.piecewiseIfString, "[CONDITION]", condition), "[IF_STATEMENT]", value); } std::string Generator::GeneratorImpl::generatePiecewiseElseCode(const std::string &value) const { - return replace(mProfile->hasConditionalOperator() ? - mProfile->conditionalOperatorElseString() : - mProfile->piecewiseElseString(), + return replace(mProfileCache.hasConditionalOperator ? + mProfileCache.conditionalOperatorElseString : + mProfileCache.piecewiseElseString, "[ELSE_STATEMENT]", value); } @@ -1335,92 +1479,96 @@ std::string Generator::GeneratorImpl::generateCode(const AnalyserEquationAstPtr switch (ast->type()) { case AnalyserEquationAst::Type::EQUALITY: - code = generateOperatorCode(mProfile->equalityString(), ast); + code = generateOperatorCode(mProfileCache.equalityString, ast); break; case AnalyserEquationAst::Type::EQ: - if (mProfile->hasEqOperator()) { - code = generateOperatorCode(mProfile->eqString(), ast); + if (mProfileCache.hasEqOperator) { + code = generateOperatorCode(mProfileCache.eqString, ast); } else { - code = generateTwoParameterFunctionCode(mProfile->eqString(), ast); + code = generateTwoParameterFunctionCode(mProfileCache.eqString, ast); } break; case AnalyserEquationAst::Type::NEQ: - if (mProfile->hasNeqOperator()) { - code = generateOperatorCode(mProfile->neqString(), ast); + if (mProfileCache.hasNeqOperator) { + code = generateOperatorCode(mProfileCache.neqString, ast); } else { - code = generateTwoParameterFunctionCode(mProfile->neqString(), ast); + code = generateTwoParameterFunctionCode(mProfileCache.neqString, ast); } break; case AnalyserEquationAst::Type::LT: - if (mProfile->hasLtOperator()) { - code = generateOperatorCode(mProfile->ltString(), ast); + if (mProfileCache.hasLtOperator) { + code = generateOperatorCode(mProfileCache.ltString, ast); } else { - code = generateTwoParameterFunctionCode(mProfile->ltString(), ast); + code = generateTwoParameterFunctionCode(mProfileCache.ltString, ast); } break; case AnalyserEquationAst::Type::LEQ: - if (mProfile->hasLeqOperator()) { - code = generateOperatorCode(mProfile->leqString(), ast); + if (mProfileCache.hasLeqOperator) { + code = generateOperatorCode(mProfileCache.leqString, ast); } else { - code = generateTwoParameterFunctionCode(mProfile->leqString(), ast); + code = generateTwoParameterFunctionCode(mProfileCache.leqString, ast); } break; case AnalyserEquationAst::Type::GT: - if (mProfile->hasGtOperator()) { - code = generateOperatorCode(mProfile->gtString(), ast); + if (mProfileCache.hasGtOperator) { + code = generateOperatorCode(mProfileCache.gtString, ast); } else { - code = generateTwoParameterFunctionCode(mProfile->gtString(), ast); + code = generateTwoParameterFunctionCode(mProfileCache.gtString, ast); } break; case AnalyserEquationAst::Type::GEQ: - if (mProfile->hasGeqOperator()) { - code = generateOperatorCode(mProfile->geqString(), ast); + if (mProfileCache.hasGeqOperator) { + code = generateOperatorCode(mProfileCache.geqString, ast); } else { - code = generateTwoParameterFunctionCode(mProfile->geqString(), ast); + code = generateTwoParameterFunctionCode(mProfileCache.geqString, ast); } break; case AnalyserEquationAst::Type::AND: - if (mProfile->hasAndOperator()) { - code = generateOperatorCode(mProfile->andString(), ast); + if (mProfileCache.hasAndOperator) { + code = generateOperatorCode(mProfileCache.andString, ast); } else { - code = generateTwoParameterFunctionCode(mProfile->andString(), ast); + code = generateTwoParameterFunctionCode(mProfileCache.andString, ast); } break; case AnalyserEquationAst::Type::OR: - if (mProfile->hasOrOperator()) { - code = generateOperatorCode(mProfile->orString(), ast); + if (mProfileCache.hasOrOperator) { + code = generateOperatorCode(mProfileCache.orString, ast); } else { - code = generateTwoParameterFunctionCode(mProfile->orString(), ast); + code = generateTwoParameterFunctionCode(mProfileCache.orString, ast); } break; case AnalyserEquationAst::Type::XOR: - if (mProfile->hasXorOperator()) { - code = generateOperatorCode(mProfile->xorString(), ast); + if (mProfileCache.hasXorOperator) { + code = generateOperatorCode(mProfileCache.xorString, ast); } else { - code = generateTwoParameterFunctionCode(mProfile->xorString(), ast); + code = generateTwoParameterFunctionCode(mProfileCache.xorString, ast); } break; case AnalyserEquationAst::Type::NOT: - if (mProfile->hasNotOperator()) { - code = mProfile->notString() + generateCode(ast->leftChild()); + if (mProfileCache.hasNotOperator) { + auto leftChildString = generateCode(ast->leftChild()); + const auto ¬String = mProfileCache.notString; + + code += notString; + code += leftChildString; } else { - code = generateOneParameterFunctionCode(mProfile->notString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.notString, ast); } break; case AnalyserEquationAst::Type::PLUS: if (ast->rightChild() != nullptr) { - code = generateOperatorCode(mProfile->plusString(), ast); + code = generateOperatorCode(mProfileCache.plusString, ast); } else { code = generateCode(ast->leftChild()); } @@ -1428,18 +1576,18 @@ std::string Generator::GeneratorImpl::generateCode(const AnalyserEquationAstPtr break; case AnalyserEquationAst::Type::MINUS: if (ast->rightChild() != nullptr) { - code = generateOperatorCode(mProfile->minusString(), ast); + code = generateOperatorCode(mProfileCache.minusString, ast); } else { code = generateMinusUnaryCode(ast); } break; case AnalyserEquationAst::Type::TIMES: - code = generateOperatorCode(mProfile->timesString(), ast); + code = generateOperatorCode(mProfileCache.timesString, ast); break; case AnalyserEquationAst::Type::DIVIDE: - code = generateOperatorCode(mProfile->divideString(), ast); + code = generateOperatorCode(mProfileCache.divideString, ast); break; case AnalyserEquationAst::Type::POWER: { @@ -1448,14 +1596,24 @@ std::string Generator::GeneratorImpl::generateCode(const AnalyserEquationAstPtr auto validConversion = convertToDouble(stringValue, doubleValue); if (validConversion && areEqual(doubleValue, 0.5)) { - code = generateOneParameterFunctionCode(mProfile->squareRootString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.squareRootString, ast); } else if (validConversion && areEqual(doubleValue, 2.0) - && !mProfile->squareString().empty()) { - code = generateOneParameterFunctionCode(mProfile->squareString(), ast); + && !mProfileCache.squareString.empty()) { + code = generateOneParameterFunctionCode(mProfileCache.squareString, ast); } else { - code = mProfile->hasPowerOperator() ? - generateOperatorCode(mProfile->powerString(), ast) : - mProfile->powerString() + "(" + generateCode(ast->leftChild()) + ", " + stringValue + ")"; + if (mProfileCache.hasPowerOperator) { + code = generateOperatorCode(mProfileCache.powerString, ast); + } else { + auto leftChildString = generateCode(ast->leftChild()); + const auto &powerString = mProfileCache.powerString; + + code += powerString; + code += '('; + code += leftChildString; + code += ", "; + code += stringValue; + code += ')'; + } } } break; case AnalyserEquationAst::Type::ROOT: { @@ -1467,10 +1625,16 @@ std::string Generator::GeneratorImpl::generateCode(const AnalyserEquationAstPtr if (convertToDouble(generateCode(astLeftChild), doubleValue) && areEqual(doubleValue, 2.0)) { - code = mProfile->squareRootString() + "(" + generateCode(astRightChild) + ")"; + auto rightChildString = generateCode(astRightChild); + const auto &squareRootString = mProfileCache.squareRootString; + + code += squareRootString; + code += '('; + code += rightChildString; + code += ')'; } else { - if (mProfile->hasPowerOperator()) { - code = generateOperatorCode(mProfile->powerString(), ast); + if (mProfileCache.hasPowerOperator) { + code = generateOperatorCode(mProfileCache.powerString, ast); } else { auto rootValueAst = AnalyserEquationAst::create(); @@ -1486,23 +1650,34 @@ std::string Generator::GeneratorImpl::generateCode(const AnalyserEquationAstPtr rootValueAst->setLeftChild(leftChild); rootValueAst->setRightChild(astLeftChild->leftChild()); - code = mProfile->powerString() + "(" + generateCode(astRightChild) + ", " + generateOperatorCode(mProfile->divideString(), rootValueAst) + ")"; + { + auto rightChildString = generateCode(astRightChild); + auto exponentString = generateOperatorCode(mProfileCache.divideString, rootValueAst); + const auto &powerString = mProfileCache.powerString; + + code += powerString; + code += '('; + code += rightChildString; + code += ", "; + code += exponentString; + code += ')'; + } } } } else { - code = generateOneParameterFunctionCode(mProfile->squareRootString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.squareRootString, ast); } } break; case AnalyserEquationAst::Type::ABS: - code = generateOneParameterFunctionCode(mProfile->absoluteValueString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.absoluteValueString, ast); break; case AnalyserEquationAst::Type::EXP: - code = generateOneParameterFunctionCode(mProfile->exponentialString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.exponentialString, ast); break; case AnalyserEquationAst::Type::LN: - code = generateOneParameterFunctionCode(mProfile->naturalLogarithmString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.naturalLogarithmString, ast); break; case AnalyserEquationAst::Type::LOG: { @@ -1514,136 +1689,158 @@ std::string Generator::GeneratorImpl::generateCode(const AnalyserEquationAstPtr if (convertToDouble(stringValue, doubleValue) && areEqual(doubleValue, 10.0)) { - code = mProfile->commonLogarithmString() + "(" + generateCode(astRightChild) + ")"; + const auto &commonLogarithmString = mProfileCache.commonLogarithmString; + auto rightChildString = generateCode(astRightChild); + + code += commonLogarithmString; + code += '('; + code += rightChildString; + code += ')'; } else { - code = mProfile->naturalLogarithmString() + "(" + generateCode(astRightChild) + ")/" + mProfile->naturalLogarithmString() + "(" + stringValue + ")"; + const auto &naturalLogarithmString = mProfileCache.naturalLogarithmString; + auto rightChildString = generateCode(astRightChild); + + code += naturalLogarithmString; + code += '('; + code += rightChildString; + code += ")/"; + code += naturalLogarithmString; + code += '('; + code += stringValue; + code += ')'; } } else { - code = generateOneParameterFunctionCode(mProfile->commonLogarithmString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.commonLogarithmString, ast); } } break; case AnalyserEquationAst::Type::CEILING: - code = generateOneParameterFunctionCode(mProfile->ceilingString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.ceilingString, ast); break; case AnalyserEquationAst::Type::FLOOR: - code = generateOneParameterFunctionCode(mProfile->floorString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.floorString, ast); break; case AnalyserEquationAst::Type::MIN: - code = generateTwoParameterFunctionCode(mProfile->minString(), ast); + code = generateTwoParameterFunctionCode(mProfileCache.minString, ast); break; case AnalyserEquationAst::Type::MAX: - code = generateTwoParameterFunctionCode(mProfile->maxString(), ast); + code = generateTwoParameterFunctionCode(mProfileCache.maxString, ast); break; case AnalyserEquationAst::Type::REM: - code = generateTwoParameterFunctionCode(mProfile->remString(), ast); + code = generateTwoParameterFunctionCode(mProfileCache.remString, ast); break; case AnalyserEquationAst::Type::DIFF: if (mAnalyserModel != nullptr) { code = generateCode(ast->rightChild()); } else { - code = "d" + generateCode(ast->rightChild()) + "/d" + generateCode(ast->leftChild()); + auto rightChildString = generateCode(ast->rightChild()); + auto leftChildString = generateCode(ast->leftChild()); + + code = 'd'; + code += rightChildString; + code += "/d"; + code += leftChildString; } break; case AnalyserEquationAst::Type::SIN: - code = generateOneParameterFunctionCode(mProfile->sinString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.sinString, ast); break; case AnalyserEquationAst::Type::COS: - code = generateOneParameterFunctionCode(mProfile->cosString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.cosString, ast); break; case AnalyserEquationAst::Type::TAN: - code = generateOneParameterFunctionCode(mProfile->tanString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.tanString, ast); break; case AnalyserEquationAst::Type::SEC: - code = generateOneParameterFunctionCode(mProfile->secString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.secString, ast); break; case AnalyserEquationAst::Type::CSC: - code = generateOneParameterFunctionCode(mProfile->cscString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.cscString, ast); break; case AnalyserEquationAst::Type::COT: - code = generateOneParameterFunctionCode(mProfile->cotString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.cotString, ast); break; case AnalyserEquationAst::Type::SINH: - code = generateOneParameterFunctionCode(mProfile->sinhString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.sinhString, ast); break; case AnalyserEquationAst::Type::COSH: - code = generateOneParameterFunctionCode(mProfile->coshString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.coshString, ast); break; case AnalyserEquationAst::Type::TANH: - code = generateOneParameterFunctionCode(mProfile->tanhString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.tanhString, ast); break; case AnalyserEquationAst::Type::SECH: - code = generateOneParameterFunctionCode(mProfile->sechString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.sechString, ast); break; case AnalyserEquationAst::Type::CSCH: - code = generateOneParameterFunctionCode(mProfile->cschString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.cschString, ast); break; case AnalyserEquationAst::Type::COTH: - code = generateOneParameterFunctionCode(mProfile->cothString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.cothString, ast); break; case AnalyserEquationAst::Type::ASIN: - code = generateOneParameterFunctionCode(mProfile->asinString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.asinString, ast); break; case AnalyserEquationAst::Type::ACOS: - code = generateOneParameterFunctionCode(mProfile->acosString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.acosString, ast); break; case AnalyserEquationAst::Type::ATAN: - code = generateOneParameterFunctionCode(mProfile->atanString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.atanString, ast); break; case AnalyserEquationAst::Type::ASEC: - code = generateOneParameterFunctionCode(mProfile->asecString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.asecString, ast); break; case AnalyserEquationAst::Type::ACSC: - code = generateOneParameterFunctionCode(mProfile->acscString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.acscString, ast); break; case AnalyserEquationAst::Type::ACOT: - code = generateOneParameterFunctionCode(mProfile->acotString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.acotString, ast); break; case AnalyserEquationAst::Type::ASINH: - code = generateOneParameterFunctionCode(mProfile->asinhString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.asinhString, ast); break; case AnalyserEquationAst::Type::ACOSH: - code = generateOneParameterFunctionCode(mProfile->acoshString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.acoshString, ast); break; case AnalyserEquationAst::Type::ATANH: - code = generateOneParameterFunctionCode(mProfile->atanhString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.atanhString, ast); break; case AnalyserEquationAst::Type::ASECH: - code = generateOneParameterFunctionCode(mProfile->asechString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.asechString, ast); break; case AnalyserEquationAst::Type::ACSCH: - code = generateOneParameterFunctionCode(mProfile->acschString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.acschString, ast); break; case AnalyserEquationAst::Type::ACOTH: - code = generateOneParameterFunctionCode(mProfile->acothString(), ast); + code = generateOneParameterFunctionCode(mProfileCache.acothString, ast); break; case AnalyserEquationAst::Type::PIECEWISE: { @@ -1651,12 +1848,12 @@ std::string Generator::GeneratorImpl::generateCode(const AnalyserEquationAstPtr if (astRightChild != nullptr) { if (astRightChild->type() == AnalyserEquationAst::Type::PIECE) { - code = generateCode(ast->leftChild()) + generatePiecewiseElseCode(generateCode(astRightChild) + generatePiecewiseElseCode(mProfile->nanString())); + code = generateCode(ast->leftChild()) + generatePiecewiseElseCode(generateCode(astRightChild) + generatePiecewiseElseCode(mProfileCache.nanString)); } else { code = generateCode(ast->leftChild()) + generatePiecewiseElseCode(generateCode(astRightChild)); } } else { - code = generateCode(ast->leftChild()) + generatePiecewiseElseCode(mProfile->nanString()); + code = generateCode(ast->leftChild()) + generatePiecewiseElseCode(mProfileCache.nanString); } } break; case AnalyserEquationAst::Type::PIECE: @@ -1698,27 +1895,27 @@ std::string Generator::GeneratorImpl::generateCode(const AnalyserEquationAstPtr break; case AnalyserEquationAst::Type::TRUE: - code = mProfile->trueString(); + code += mProfileCache.trueString; break; case AnalyserEquationAst::Type::FALSE: - code = mProfile->falseString(); + code += mProfileCache.falseString; break; case AnalyserEquationAst::Type::E: - code = mProfile->eString(); + code += mProfileCache.eString; break; case AnalyserEquationAst::Type::PI: - code = mProfile->piString(); + code += mProfileCache.piString; break; case AnalyserEquationAst::Type::INF: - code = mProfile->infString(); + code += mProfileCache.infString; break; default: // AnalyserEquationAst::Type::NAN. - code = mProfile->nanString(); + code += mProfileCache.nanString; break; } @@ -1761,11 +1958,11 @@ bool Generator::GeneratorImpl::isSomeConstant(const AnalyserEquationPtr &analyse std::string Generator::GeneratorImpl::generateZeroInitialisationCode(const AnalyserVariablePtr &analyserVariable) { - return mProfile->indentString() + return mProfileCache.indentString + generateVariableNameCode(analyserVariable->variable(), false) - + mProfile->equalityString() + + mProfileCache.equalityString + "0.0" - + mProfile->commandSeparatorString() + "\n"; + + mProfileCache.commandSeparatorString + "\n"; } std::string Generator::GeneratorImpl::generateInitialisationCode(const AnalyserVariablePtr &analyserVariable, bool force) @@ -1779,41 +1976,40 @@ std::string Generator::GeneratorImpl::generateInitialisationCode(const AnalyserV std::string scalingFactorCode; if (!areNearlyEqual(scalingFactor, 1.0)) { - scalingFactorCode = generateDoubleCode(convertToString(scalingFactor)) + mProfile->timesString(); + scalingFactorCode = generateDoubleCode(convertToString(scalingFactor)) + mProfileCache.timesString; } auto code = generateVariableNameCode(analyserVariable->variable()) - + mProfile->equalityString() + + mProfileCache.equalityString + scalingFactorCode + generateDoubleOrVariableNameCode(initialisingVariable) - + mProfile->commandSeparatorString() + "\n"; + + mProfileCache.commandSeparatorString + "\n"; if (isTrackedVariable(analyserVariable, false)) { - code = replace(mProfile->variableDeclarationString(), "[CODE]", code); + code = replace(mProfileCache.variableDeclarationString, "[CODE]", code); } - return mProfile->indentString() - + code; + return mProfileCache.indentString + code; } std::string Generator::GeneratorImpl::generateEquationCode(const AnalyserEquationPtr &analyserEquation, - std::vector &remainingAnalyserEquations, - std::vector &analyserEquationsForDependencies, - std::vector &generatedConstantDependencies, + std::unordered_set &remainingAnalyserEquations, + std::unordered_set &analyserEquationsForDependencies, + std::unordered_set &generatedConstantDependencies, bool includeComputedConstants, GenerateEquationCodeTarget target) { std::string res; - if (std::find(remainingAnalyserEquations.begin(), remainingAnalyserEquations.end(), analyserEquation) != remainingAnalyserEquations.end()) { + if (remainingAnalyserEquations.count(analyserEquation) != 0) { // Stop tracking the analyser equation and its NLA siblings, if any. // Note: we need to do this as soon as possible to avoid recursive // calls, something that would happen if we were to do this at the // end of this if statement. - remainingAnalyserEquations.erase(std::find(remainingAnalyserEquations.begin(), remainingAnalyserEquations.end(), analyserEquation)); + remainingAnalyserEquations.erase(analyserEquation); for (const auto &nlaSibling : analyserEquation->nlaSiblings()) { - remainingAnalyserEquations.erase(std::find(remainingAnalyserEquations.begin(), remainingAnalyserEquations.end(), nlaSibling)); + remainingAnalyserEquations.erase(nlaSibling); } // Generate any dependency that this analyser equation may have. @@ -1821,30 +2017,26 @@ std::string Generator::GeneratorImpl::generateEquationCode(const AnalyserEquatio for (const auto &constantDependency : analyserEquation->mPimpl->mConstantDependencies) { if ((analyserEquation->type() != AnalyserEquation::Type::NLA) && isTrackedVariable(constantDependency, false) - && (std::find(generatedConstantDependencies.begin(), generatedConstantDependencies.end(), constantDependency) == generatedConstantDependencies.end())) { + && (generatedConstantDependencies.count(constantDependency) == 0)) { res += generateInitialisationCode(constantDependency, true); - generatedConstantDependencies.push_back(constantDependency); + generatedConstantDependencies.insert(constantDependency); } } - if (!isSomeConstant(analyserEquation, includeComputedConstants)) { + if (!isSomeConstant(analyserEquation, includeComputedConstants) + || (target == GenerateEquationCodeTarget::OBJECTIVE_FUNCTION)) { for (const auto &dependency : analyserEquation->dependencies()) { if (((analyserEquation->type() != AnalyserEquation::Type::NLA) && (dependency->type() == AnalyserEquation::Type::COMPUTED_CONSTANT) && isTrackedEquation(dependency, false)) - || (((target == GenerateEquationCodeTarget::NORMAL) - || ((target == GenerateEquationCodeTarget::COMPUTE_VARIABLES) - && ((dependency->type() != AnalyserEquation::Type::NLA) - || isToBeComputedAgain(dependency) - || (std::find(analyserEquationsForDependencies.begin(), analyserEquationsForDependencies.end(), dependency) != analyserEquationsForDependencies.end())))) - && (dependency->type() != AnalyserEquation::Type::ODE) + || ((dependency->type() != AnalyserEquation::Type::ODE) && (isTrackedEquation(dependency, true) || (analyserEquation->type() != AnalyserEquation::Type::NLA)) && !isSomeConstant(dependency, includeComputedConstants) && (analyserEquationsForDependencies.empty() || isToBeComputedAgain(dependency) - || (std::find(analyserEquationsForDependencies.begin(), analyserEquationsForDependencies.end(), dependency) != analyserEquationsForDependencies.end())))) { + || (analyserEquationsForDependencies.count(dependency) != 0)))) { res += generateEquationCode(dependency, remainingAnalyserEquations, analyserEquationsForDependencies, generatedConstantDependencies, includeComputedConstants, target); } @@ -1885,10 +2077,10 @@ std::string Generator::GeneratorImpl::generateEquationCode(const AnalyserEquatio } std::string Generator::GeneratorImpl::generateEquationCode(const AnalyserEquationPtr &analyserEquation, - std::vector &remainingAnalyserEquations, - std::vector &generatedConstantDependencies) + std::unordered_set &remainingAnalyserEquations, + std::unordered_set &generatedConstantDependencies) { - std::vector dummyAnalyserEquationsForComputeVariables; + std::unordered_set dummyAnalyserEquationsForComputeVariables; return generateEquationCode(analyserEquation, remainingAnalyserEquations, dummyAnalyserEquationsForComputeVariables, generatedConstantDependencies, true); @@ -1913,12 +2105,12 @@ bool Generator::GeneratorImpl::hasComputedConstantDependency(const AnalyserVaria } std::string Generator::GeneratorImpl::generateInitialiseVariableCode(const AnalyserVariablePtr &analyserVariable, - std::vector &remainingAnalyserEquations, + std::unordered_set &remainingAnalyserEquations, std::vector &remainingStates, std::vector &remainingConstants, std::vector &remainingComputedConstants, std::vector &remainingAlgebraicVariables, - std::vector *generatedConstantDependencies) + std::unordered_set *generatedConstantDependencies) { std::string res; @@ -1937,9 +2129,7 @@ std::string Generator::GeneratorImpl::generateInitialiseVariableCode(const Analy remainingStates : (initialValueAnalyserVariable->type() == AnalyserVariable::Type::CONSTANT) ? remainingConstants : - (initialValueAnalyserVariable->type() == AnalyserVariable::Type::COMPUTED_CONSTANT) ? - remainingComputedConstants : - remainingAlgebraicVariables; + remainingComputedConstants; if (((generatedConstantDependencies == nullptr) && !hasComputedConstantDependency(initialValueAnalyserVariable)) || (generatedConstantDependencies != nullptr)) { @@ -1966,9 +2156,7 @@ std::string Generator::GeneratorImpl::generateInitialiseVariableCode(const Analy remainingStates : (analyserVariable->type() == AnalyserVariable::Type::CONSTANT) ? remainingConstants : - (analyserVariable->type() == AnalyserVariable::Type::COMPUTED_CONSTANT) ? - remainingComputedConstants : - remainingAlgebraicVariables; + remainingComputedConstants; auto remainingVariable = std::find(remainingVariables.begin(), remainingVariables.end(), analyserVariable); if (remainingVariable != remainingVariables.end()) { @@ -1987,38 +2175,39 @@ std::string Generator::GeneratorImpl::generateInitialiseVariableCode(const Analy void Generator::GeneratorImpl::addInterfaceComputeModelMethodsCode() { - auto interfaceInitialiseArraysMethodString = mProfile->interfaceInitialiseArraysMethodString(modelHasOdes(mAnalyserModel)); + const auto &interfaceInitialiseArraysMethodString = mProfile->interfaceInitialiseArraysMethodString(modelHasOdes(mAnalyserModel)); std::string code; if (!interfaceInitialiseArraysMethodString.empty()) { code += interfaceInitialiseArraysMethodString; } - if (!mProfile->interfaceComputeComputedConstantsMethodString(modelHasOdes(mAnalyserModel)).empty()) { - code += mProfile->interfaceComputeComputedConstantsMethodString(modelHasOdes(mAnalyserModel)); + const auto &interfaceComputeComputedConstantsMethodString = mProfile->interfaceComputeComputedConstantsMethodString(modelHasOdes(mAnalyserModel)); + + if (!interfaceComputeComputedConstantsMethodString.empty()) { + code += interfaceComputeComputedConstantsMethodString; } - auto interfaceComputeRatesMethodString = mProfile->interfaceComputeRatesMethodString(mAnalyserModel->hasExternalVariables()); + const auto &interfaceComputeRatesMethodString = mProfile->interfaceComputeRatesMethodString(mAnalyserModel->hasExternalVariables()); if (modelHasOdes(mAnalyserModel) && !interfaceComputeRatesMethodString.empty()) { code += interfaceComputeRatesMethodString; } - auto interfaceComputeVariablesMethodString = mProfile->interfaceComputeVariablesMethodString(modelHasOdes(mAnalyserModel), - mAnalyserModel->hasExternalVariables()); + const auto &interfaceComputeVariablesMethodString = mProfile->interfaceComputeVariablesMethodString(modelHasOdes(mAnalyserModel), + mAnalyserModel->hasExternalVariables()); if (!interfaceComputeVariablesMethodString.empty()) { code += interfaceComputeVariablesMethodString; } if (!code.empty()) { - mCode += newLineIfNeeded() - + code; + addCode(code); } } -void Generator::GeneratorImpl::addImplementationInitialiseArraysMethodCode(std::vector &remainingAnalyserEquations, +void Generator::GeneratorImpl::addImplementationInitialiseArraysMethodCode(std::unordered_set &remainingAnalyserEquations, std::vector &remainingStates, std::vector &remainingConstants, std::vector &remainingComputedConstants, @@ -2038,14 +2227,6 @@ void Generator::GeneratorImpl::addImplementationInitialiseArraysMethodCode(std:: remainingComputedConstants, remainingAlgebraicVariables); } - // Use an initial guess of zero for rates computed using an NLA system (see the note below). - - for (const auto &state : mAnalyserModel->states()) { - if (state->analyserEquation(0)->type() == AnalyserEquation::Type::NLA) { - methodBody += generateZeroInitialisationCode(state); - } - } - // Initialise our remaining constants. while (!remainingConstants.empty()) { @@ -2057,53 +2238,46 @@ void Generator::GeneratorImpl::addImplementationInitialiseArraysMethodCode(std:: // Initialise our computed constants that are initialised using an equation (e.g., x = 3 rather than x with an // initial value of 3). - std::vector generatedConstantDependencies; + std::unordered_set generatedConstantDependencies; for (const auto &equation : mAnalyserModel->analyserEquations()) { - if (equation->type() == AnalyserEquation::Type::CONSTANT) { + if ((equation->type() == AnalyserEquation::Type::CONSTANT) + && isTrackedVariable(equation->computedConstants().front(), true)) { methodBody += generateEquationCode(equation, remainingAnalyserEquations, 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. + // Use an initial guess of zero for algebraic variables computed using an NLA system. for (const auto &algebraicVariable : mAnalyserModel->algebraicVariables()) { - if (algebraicVariable->initialisingVariable() != nullptr) { - methodBody += generateInitialiseVariableCode(algebraicVariable, - remainingAnalyserEquations, remainingStates, remainingConstants, - remainingComputedConstants, remainingAlgebraicVariables); - } else if (algebraicVariable->analyserEquation(0)->type() == AnalyserEquation::Type::NLA) { + if (algebraicVariable->analyserEquation(0)->type() == AnalyserEquation::Type::NLA) { methodBody += generateZeroInitialisationCode(algebraicVariable); } } // Generate the method itself, if needed. - auto implementationInitialiseArraysMethodString = mProfile->implementationInitialiseArraysMethodString(modelHasOdes(mAnalyserModel)); + const auto &implementationInitialiseArraysMethodString = mProfile->implementationInitialiseArraysMethodString(modelHasOdes(mAnalyserModel)); if (!implementationInitialiseArraysMethodString.empty()) { - mCode += newLineIfNeeded() - + replace(implementationInitialiseArraysMethodString, - "[CODE]", generateMethodBodyCode(methodBody)); + addCode(replace(implementationInitialiseArraysMethodString, + "[CODE]", generateMethodBodyCode(methodBody))); } } -void Generator::GeneratorImpl::addImplementationComputeComputedConstantsMethodCode(std::vector &remainingAnalyserEquations, +void Generator::GeneratorImpl::addImplementationComputeComputedConstantsMethodCode(std::unordered_set &remainingAnalyserEquations, std::vector &remainingStates, std::vector &remainingConstants, std::vector &remainingComputedConstants, std::vector &remainingAlgebraicVariables) { - if (!mProfile->implementationComputeComputedConstantsMethodString(modelHasOdes(mAnalyserModel)).empty()) { + const auto &implementationComputeComputedConstantsMethodString = mProfile->implementationComputeComputedConstantsMethodString(modelHasOdes(mAnalyserModel)); + + if (!implementationComputeComputedConstantsMethodString.empty()) { // Initialise our remaining states (which are initialised using a computed constant). std::string methodBody; - std::vector generatedConstantDependencies; + std::unordered_set generatedConstantDependencies; for (const auto &state : mAnalyserModel->states()) { methodBody += generateInitialiseVariableCode(state, @@ -2124,66 +2298,44 @@ void Generator::GeneratorImpl::addImplementationComputeComputedConstantsMethodCo } } - // Initialise our algebraic variables that are initialised using a computed constant. - - for (const auto &algebraicVariable : mAnalyserModel->algebraicVariables()) { - if (algebraicVariable->initialisingVariable() != nullptr) { - methodBody += generateInitialiseVariableCode(algebraicVariable, - remainingAnalyserEquations, remainingStates, remainingConstants, - remainingComputedConstants, remainingAlgebraicVariables, - &generatedConstantDependencies); - } - } - - mCode += newLineIfNeeded() - + replace(mProfile->implementationComputeComputedConstantsMethodString(modelHasOdes(mAnalyserModel)), - "[CODE]", generateMethodBodyCode(methodBody)); + addCode(replace(implementationComputeComputedConstantsMethodString, + "[CODE]", generateMethodBodyCode(methodBody))); } } -void Generator::GeneratorImpl::addImplementationComputeRatesMethodCode(std::vector &remainingAnalyserEquations) +void Generator::GeneratorImpl::addImplementationComputeRatesMethodCode(std::unordered_set &remainingAnalyserEquations) { - auto implementationComputeRatesMethodString = mProfile->implementationComputeRatesMethodString(mAnalyserModel->hasExternalVariables()); + const auto &implementationComputeRatesMethodString = mProfile->implementationComputeRatesMethodString(mAnalyserModel->hasExternalVariables()); if (modelHasOdes(mAnalyserModel) && !implementationComputeRatesMethodString.empty()) { std::string methodBody; - std::vector generatedConstantDependencies; + std::unordered_set generatedConstantDependencies; for (const auto &analyserEquation : mAnalyserModel->analyserEquations()) { - // A rate is computed either through an ODE equation or through an - // NLA equation in case the rate is not on its own on either the LHS - // or RHS of the equation. - - auto analyserVariables = libcellml::analyserVariables(analyserEquation); - - if ((analyserEquation->type() == AnalyserEquation::Type::ODE) - || ((analyserEquation->type() == AnalyserEquation::Type::NLA) - && (analyserVariables.size() == 1) - && (analyserVariables[0]->type() == AnalyserVariable::Type::STATE))) { + if (analyserEquation->type() == AnalyserEquation::Type::ODE) { methodBody += generateEquationCode(analyserEquation, remainingAnalyserEquations, generatedConstantDependencies); } } - mCode += newLineIfNeeded() - + replace(implementationComputeRatesMethodString, - "[CODE]", generateMethodBodyCode(methodBody)); + addCode(replace(implementationComputeRatesMethodString, + "[CODE]", generateMethodBodyCode(methodBody))); } } -void Generator::GeneratorImpl::addImplementationComputeVariablesMethodCode(std::vector &remainingAnalyserEquations) +void Generator::GeneratorImpl::addImplementationComputeVariablesMethodCode(std::unordered_set &remainingAnalyserEquations) { - auto implementationComputeVariablesMethodString = mProfile->implementationComputeVariablesMethodString(modelHasOdes(mAnalyserModel), - mAnalyserModel->hasExternalVariables()); + const auto &implementationComputeVariablesMethodString = mProfile->implementationComputeVariablesMethodString(modelHasOdes(mAnalyserModel), + mAnalyserModel->hasExternalVariables()); if (!implementationComputeVariablesMethodString.empty()) { std::string methodBody; - auto analyserEquations = mAnalyserModel->analyserEquations(); - auto newRemainingAnalyserEquations = analyserEquations; - std::vector generatedConstantDependencies; + const auto &analyserEquations = mAnalyserModel->analyserEquations(); + std::unordered_set newRemainingAnalyserEquations(analyserEquations.begin(), analyserEquations.end()); + std::unordered_set generatedConstantDependencies; for (const auto &analyserEquation : analyserEquations) { - if (((std::find(remainingAnalyserEquations.begin(), remainingAnalyserEquations.end(), analyserEquation) != remainingAnalyserEquations.end()) + if (((remainingAnalyserEquations.count(analyserEquation) != 0) || isToBeComputedAgain(analyserEquation)) && isTrackedEquation(analyserEquation, true)) { methodBody += generateEquationCode(analyserEquation, newRemainingAnalyserEquations, remainingAnalyserEquations, @@ -2192,9 +2344,8 @@ void Generator::GeneratorImpl::addImplementationComputeVariablesMethodCode(std:: } } - mCode += newLineIfNeeded() - + replace(implementationComputeVariablesMethodString, - "[CODE]", generateMethodBodyCode(methodBody)); + addCode(replace(implementationComputeVariablesMethodString, + "[CODE]", generateMethodBodyCode(methodBody))); } } @@ -2244,6 +2395,7 @@ std::string Generator::interfaceCode(const AnalyserModelPtr &analyserModel, cons // Get ourselves ready. pFunc()->reset(); + pFunc()->initProfileCache(); // Add code for the origin comment. @@ -2327,6 +2479,7 @@ std::string Generator::implementationCode(const AnalyserModelPtr &analyserModel, // Get ourselves ready. pFunc()->reset(); + pFunc()->initProfileCache(); // Add code for the origin comment. @@ -2385,7 +2538,8 @@ std::string Generator::implementationCode(const AnalyserModelPtr &analyserModel, // Add code for the implementation to initialise our arrays. - auto remainingAnalyserEquations = pFunc()->mAnalyserModel->analyserEquations(); + const auto &analyserEquations = pFunc()->mAnalyserModel->analyserEquations(); + std::unordered_set remainingAnalyserEquations(analyserEquations.begin(), analyserEquations.end()); auto remainingStates = pFunc()->mAnalyserModel->states(); auto remainingConstants = pFunc()->mAnalyserModel->constants(); auto remainingComputedConstants = pFunc()->mAnalyserModel->computedConstants(); @@ -2448,6 +2602,8 @@ std::string Generator::equationCode(const AnalyserEquationAstPtr &ast, generator->pFunc()->mProfile = (generatorProfile != nullptr) ? generatorProfile : generator->pFunc()->mDefaultProfile; + generator->pFunc()->initProfileCache(); + return generator->pFunc()->generateCode(ast); } diff --git a/src/generator_p.h b/src/generator_p.h index 5c1a3f642a..eda2fb8c75 100644 --- a/src/generator_p.h +++ b/src/generator_p.h @@ -42,6 +42,110 @@ struct Generator::GeneratorImpl: public Logger::LoggerImpl GeneratorProfilePtr mProfile; GeneratorVariableTrackerPtr mVariableTracker; + /** + * @brief Cached profile accessors to avoid virtual dispatch overhead. + * + * Populated by initProfileCache() at the start of each code generation run. + */ + struct ProfileCache + { + // Boolean operator flags. + + bool hasEqOperator = false; + bool hasNeqOperator = false; + bool hasLtOperator = false; + bool hasLeqOperator = false; + bool hasGtOperator = false; + bool hasGeqOperator = false; + bool hasAndOperator = false; + bool hasOrOperator = false; + bool hasXorOperator = false; + bool hasNotOperator = false; + bool hasPowerOperator = false; + bool hasConditionalOperator = false; + + // Hot-path strings. + + std::string equalityString; + std::string eqString; + std::string neqString; + std::string ltString; + std::string leqString; + std::string gtString; + std::string geqString; + std::string andString; + std::string orString; + std::string xorString; + std::string notString; + std::string plusString; + std::string minusString; + std::string timesString; + std::string divideString; + std::string powerString; + std::string squareRootString; + std::string squareString; + std::string absoluteValueString; + std::string exponentialString; + std::string naturalLogarithmString; + std::string commonLogarithmString; + std::string ceilingString; + std::string floorString; + std::string minString; + std::string maxString; + std::string remString; + std::string sinString; + std::string cosString; + std::string tanString; + std::string secString; + std::string cscString; + std::string cotString; + std::string sinhString; + std::string coshString; + std::string tanhString; + std::string sechString; + std::string cschString; + std::string cothString; + std::string asinString; + std::string acosString; + std::string atanString; + std::string asecString; + std::string acscString; + std::string acotString; + std::string asinhString; + std::string acoshString; + std::string atanhString; + std::string asechString; + std::string acschString; + std::string acothString; + std::string trueString; + std::string falseString; + std::string eString; + std::string piString; + std::string infString; + std::string nanString; + std::string indentString; + std::string openArrayString; + std::string closeArrayString; + std::string commandSeparatorString; + std::string arrayElementSeparatorString; + std::string variableDeclarationString; + std::string statesArrayString; + std::string ratesArrayString; + std::string constantsArrayString; + std::string computedConstantsArrayString; + std::string algebraicVariablesArrayString; + std::string externalVariablesArrayString; + std::string voiString; + std::string uArrayString; + std::string fArrayString; + std::string conditionalOperatorIfString; + std::string conditionalOperatorElseString; + std::string piecewiseIfString; + std::string piecewiseElseString; + } mutable mProfileCache; + + void initProfileCache(); + void reset(); std::string analyserVariableIndexString(const AnalyserVariablePtr &analyserVariable); @@ -53,8 +157,6 @@ struct Generator::GeneratorImpl: public Logger::LoggerImpl double scalingFactor(const AnalyserModelPtr &analyserModel, const VariablePtr &variable) const; - bool isNegativeNumber(const AnalyserEquationAstPtr &ast) const; - bool isRelationalOperator(const AnalyserEquationAstPtr &ast) const; bool isAndOperator(const AnalyserEquationAstPtr &ast) const; bool isOrOperator(const AnalyserEquationAstPtr &ast) const; @@ -74,7 +176,7 @@ struct Generator::GeneratorImpl: public Logger::LoggerImpl bool modifiedProfile() const; - std::string newLineIfNeeded(); + void addCode(const std::string &code); void addOriginCommentCode(); @@ -138,36 +240,36 @@ struct Generator::GeneratorImpl: public Logger::LoggerImpl std::string generateZeroInitialisationCode(const AnalyserVariablePtr &analyserVariable); std::string generateInitialisationCode(const AnalyserVariablePtr &analyserVariable, bool force = false); std::string generateEquationCode(const AnalyserEquationPtr &analyserEquation, - std::vector &remainingAnalyserEquations, - std::vector &analyserEquationsForDependencies, - std::vector &generatedConstantDependencies, + std::unordered_set &remainingAnalyserEquations, + std::unordered_set &analyserEquationsForDependencies, + std::unordered_set &generatedConstantDependencies, bool includeComputedConstants, GenerateEquationCodeTarget target = GenerateEquationCodeTarget::NORMAL); std::string generateEquationCode(const AnalyserEquationPtr &analyserEquation, - std::vector &remainingAnalyserEquations, - std::vector &generatedConstantDependencies); + std::unordered_set &remainingAnalyserEquations, + std::unordered_set &generatedConstantDependencies); bool hasComputedConstantDependency(const AnalyserVariablePtr &analyserVariable); std::string generateInitialiseVariableCode(const AnalyserVariablePtr &analyserVariable, - std::vector &remainingAnalyserEquations, + std::unordered_set &remainingAnalyserEquations, std::vector &remainingStates, std::vector &remainingConstants, std::vector &remainingComputedConstants, std::vector &remainingAlgebraicVariables, - std::vector *generatedConstantDependencies = nullptr); + std::unordered_set *generatedConstantDependencies = nullptr); void addInterfaceComputeModelMethodsCode(); - void addImplementationInitialiseArraysMethodCode(std::vector &remainingAnalyserEquations, + void addImplementationInitialiseArraysMethodCode(std::unordered_set &remainingAnalyserEquations, std::vector &remainingStates, std::vector &remainingConstants, std::vector &remainingComputedConstants, std::vector &remainingAlgebraicVariables); - void addImplementationComputeComputedConstantsMethodCode(std::vector &remainingAnalyserEquations, + void addImplementationComputeComputedConstantsMethodCode(std::unordered_set &remainingAnalyserEquations, std::vector &remainingStates, std::vector &remainingConstants, std::vector &remainingComputedConstants, std::vector &remainingAlgebraicVariables); - void addImplementationComputeRatesMethodCode(std::vector &remainingAnalyserEquations); - void addImplementationComputeVariablesMethodCode(std::vector &remainingAnalyserEquations); + void addImplementationComputeRatesMethodCode(std::unordered_set &remainingAnalyserEquations); + void addImplementationComputeVariablesMethodCode(std::unordered_set &remainingAnalyserEquations); }; } // namespace libcellml diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 9fdfbc3484..925b2c2bbd 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -1026,7 +1026,7 @@ void GeneratorProfile::setHasInterface(bool hasInterface) mPimpl->mHasInterface = hasInterface; } -std::string GeneratorProfile::equalityString() const +const std::string &GeneratorProfile::equalityString() const { return mPimpl->mEqualityString; } @@ -1036,7 +1036,7 @@ void GeneratorProfile::setEqualityString(const std::string &equalityString) mPimpl->mEqualityString = equalityString; } -std::string GeneratorProfile::eqString() const +const std::string &GeneratorProfile::eqString() const { return mPimpl->mEqString; } @@ -1046,7 +1046,7 @@ void GeneratorProfile::setEqString(const std::string &eqString) mPimpl->mEqString = eqString; } -std::string GeneratorProfile::neqString() const +const std::string &GeneratorProfile::neqString() const { return mPimpl->mNeqString; } @@ -1056,7 +1056,7 @@ void GeneratorProfile::setNeqString(const std::string &neqString) mPimpl->mNeqString = neqString; } -std::string GeneratorProfile::ltString() const +const std::string &GeneratorProfile::ltString() const { return mPimpl->mLtString; } @@ -1066,7 +1066,7 @@ void GeneratorProfile::setLtString(const std::string <String) mPimpl->mLtString = ltString; } -std::string GeneratorProfile::leqString() const +const std::string &GeneratorProfile::leqString() const { return mPimpl->mLeqString; } @@ -1076,7 +1076,7 @@ void GeneratorProfile::setLeqString(const std::string &leqString) mPimpl->mLeqString = leqString; } -std::string GeneratorProfile::gtString() const +const std::string &GeneratorProfile::gtString() const { return mPimpl->mGtString; } @@ -1086,7 +1086,7 @@ void GeneratorProfile::setGtString(const std::string >String) mPimpl->mGtString = gtString; } -std::string GeneratorProfile::geqString() const +const std::string &GeneratorProfile::geqString() const { return mPimpl->mGeqString; } @@ -1096,7 +1096,7 @@ void GeneratorProfile::setGeqString(const std::string &geqString) mPimpl->mGeqString = geqString; } -std::string GeneratorProfile::andString() const +const std::string &GeneratorProfile::andString() const { return mPimpl->mAndString; } @@ -1106,7 +1106,7 @@ void GeneratorProfile::setAndString(const std::string &andString) mPimpl->mAndString = andString; } -std::string GeneratorProfile::orString() const +const std::string &GeneratorProfile::orString() const { return mPimpl->mOrString; } @@ -1116,7 +1116,7 @@ void GeneratorProfile::setOrString(const std::string &orString) mPimpl->mOrString = orString; } -std::string GeneratorProfile::xorString() const +const std::string &GeneratorProfile::xorString() const { return mPimpl->mXorString; } @@ -1126,7 +1126,7 @@ void GeneratorProfile::setXorString(const std::string &xorString) mPimpl->mXorString = xorString; } -std::string GeneratorProfile::notString() const +const std::string &GeneratorProfile::notString() const { return mPimpl->mNotString; } @@ -1236,7 +1236,7 @@ void GeneratorProfile::setHasNotOperator(bool hasNotOperator) mPimpl->mHasNotOperator = hasNotOperator; } -std::string GeneratorProfile::plusString() const +const std::string &GeneratorProfile::plusString() const { return mPimpl->mPlusString; } @@ -1246,7 +1246,7 @@ void GeneratorProfile::setPlusString(const std::string &plusString) mPimpl->mPlusString = plusString; } -std::string GeneratorProfile::minusString() const +const std::string &GeneratorProfile::minusString() const { return mPimpl->mMinusString; } @@ -1256,7 +1256,7 @@ void GeneratorProfile::setMinusString(const std::string &minusString) mPimpl->mMinusString = minusString; } -std::string GeneratorProfile::timesString() const +const std::string &GeneratorProfile::timesString() const { return mPimpl->mTimesString; } @@ -1266,7 +1266,7 @@ void GeneratorProfile::setTimesString(const std::string ×String) mPimpl->mTimesString = timesString; } -std::string GeneratorProfile::divideString() const +const std::string &GeneratorProfile::divideString() const { return mPimpl->mDivideString; } @@ -1276,7 +1276,7 @@ void GeneratorProfile::setDivideString(const std::string ÷String) mPimpl->mDivideString = divideString; } -std::string GeneratorProfile::powerString() const +const std::string &GeneratorProfile::powerString() const { return mPimpl->mPowerString; } @@ -1286,7 +1286,7 @@ void GeneratorProfile::setPowerString(const std::string &powerString) mPimpl->mPowerString = powerString; } -std::string GeneratorProfile::squareRootString() const +const std::string &GeneratorProfile::squareRootString() const { return mPimpl->mSquareRootString; } @@ -1296,7 +1296,7 @@ void GeneratorProfile::setSquareRootString(const std::string &squareRootString) mPimpl->mSquareRootString = squareRootString; } -std::string GeneratorProfile::squareString() const +const std::string &GeneratorProfile::squareString() const { return mPimpl->mSquareString; } @@ -1306,7 +1306,7 @@ void GeneratorProfile::setSquareString(const std::string &squareString) mPimpl->mSquareString = squareString; } -std::string GeneratorProfile::absoluteValueString() const +const std::string &GeneratorProfile::absoluteValueString() const { return mPimpl->mAbsoluteValueString; } @@ -1316,7 +1316,7 @@ void GeneratorProfile::setAbsoluteValueString(const std::string &absoluteValueSt mPimpl->mAbsoluteValueString = absoluteValueString; } -std::string GeneratorProfile::exponentialString() const +const std::string &GeneratorProfile::exponentialString() const { return mPimpl->mExponentialString; } @@ -1326,7 +1326,7 @@ void GeneratorProfile::setExponentialString(const std::string &exponentialString mPimpl->mExponentialString = exponentialString; } -std::string GeneratorProfile::naturalLogarithmString() const +const std::string &GeneratorProfile::naturalLogarithmString() const { return mPimpl->mNaturalLogarithmString; } @@ -1336,7 +1336,7 @@ void GeneratorProfile::setNaturalLogarithmString(const std::string &naturalLogar mPimpl->mNaturalLogarithmString = naturalLogarithmString; } -std::string GeneratorProfile::commonLogarithmString() const +const std::string &GeneratorProfile::commonLogarithmString() const { return mPimpl->mCommonLogarithmString; } @@ -1346,7 +1346,7 @@ void GeneratorProfile::setCommonLogarithmString(const std::string &commonLogarit mPimpl->mCommonLogarithmString = commonLogarithmString; } -std::string GeneratorProfile::ceilingString() const +const std::string &GeneratorProfile::ceilingString() const { return mPimpl->mCeilingString; } @@ -1356,7 +1356,7 @@ void GeneratorProfile::setCeilingString(const std::string &ceilingString) mPimpl->mCeilingString = ceilingString; } -std::string GeneratorProfile::floorString() const +const std::string &GeneratorProfile::floorString() const { return mPimpl->mFloorString; } @@ -1366,7 +1366,7 @@ void GeneratorProfile::setFloorString(const std::string &floorString) mPimpl->mFloorString = floorString; } -std::string GeneratorProfile::minString() const +const std::string &GeneratorProfile::minString() const { return mPimpl->mMinString; } @@ -1376,7 +1376,7 @@ void GeneratorProfile::setMinString(const std::string &minString) mPimpl->mMinString = minString; } -std::string GeneratorProfile::maxString() const +const std::string &GeneratorProfile::maxString() const { return mPimpl->mMaxString; } @@ -1386,7 +1386,7 @@ void GeneratorProfile::setMaxString(const std::string &maxString) mPimpl->mMaxString = maxString; } -std::string GeneratorProfile::remString() const +const std::string &GeneratorProfile::remString() const { return mPimpl->mRemString; } @@ -1406,7 +1406,7 @@ void GeneratorProfile::setHasPowerOperator(bool hasPowerOperator) mPimpl->mHasPowerOperator = hasPowerOperator; } -std::string GeneratorProfile::sinString() const +const std::string &GeneratorProfile::sinString() const { return mPimpl->mSinString; } @@ -1416,7 +1416,7 @@ void GeneratorProfile::setSinString(const std::string &sinString) mPimpl->mSinString = sinString; } -std::string GeneratorProfile::cosString() const +const std::string &GeneratorProfile::cosString() const { return mPimpl->mCosString; } @@ -1426,7 +1426,7 @@ void GeneratorProfile::setCosString(const std::string &cosString) mPimpl->mCosString = cosString; } -std::string GeneratorProfile::tanString() const +const std::string &GeneratorProfile::tanString() const { return mPimpl->mTanString; } @@ -1436,7 +1436,7 @@ void GeneratorProfile::setTanString(const std::string &tanString) mPimpl->mTanString = tanString; } -std::string GeneratorProfile::secString() const +const std::string &GeneratorProfile::secString() const { return mPimpl->mSecString; } @@ -1446,7 +1446,7 @@ void GeneratorProfile::setSecString(const std::string &secString) mPimpl->mSecString = secString; } -std::string GeneratorProfile::cscString() const +const std::string &GeneratorProfile::cscString() const { return mPimpl->mCscString; } @@ -1456,7 +1456,7 @@ void GeneratorProfile::setCscString(const std::string &cscString) mPimpl->mCscString = cscString; } -std::string GeneratorProfile::cotString() const +const std::string &GeneratorProfile::cotString() const { return mPimpl->mCotString; } @@ -1466,7 +1466,7 @@ void GeneratorProfile::setCotString(const std::string &cotString) mPimpl->mCotString = cotString; } -std::string GeneratorProfile::sinhString() const +const std::string &GeneratorProfile::sinhString() const { return mPimpl->mSinhString; } @@ -1476,7 +1476,7 @@ void GeneratorProfile::setSinhString(const std::string &sinhString) mPimpl->mSinhString = sinhString; } -std::string GeneratorProfile::coshString() const +const std::string &GeneratorProfile::coshString() const { return mPimpl->mCoshString; } @@ -1486,7 +1486,7 @@ void GeneratorProfile::setCoshString(const std::string &coshString) mPimpl->mCoshString = coshString; } -std::string GeneratorProfile::tanhString() const +const std::string &GeneratorProfile::tanhString() const { return mPimpl->mTanhString; } @@ -1496,7 +1496,7 @@ void GeneratorProfile::setTanhString(const std::string &tanhString) mPimpl->mTanhString = tanhString; } -std::string GeneratorProfile::sechString() const +const std::string &GeneratorProfile::sechString() const { return mPimpl->mSechString; } @@ -1506,7 +1506,7 @@ void GeneratorProfile::setSechString(const std::string &sechString) mPimpl->mSechString = sechString; } -std::string GeneratorProfile::cschString() const +const std::string &GeneratorProfile::cschString() const { return mPimpl->mCschString; } @@ -1516,7 +1516,7 @@ void GeneratorProfile::setCschString(const std::string &cschString) mPimpl->mCschString = cschString; } -std::string GeneratorProfile::cothString() const +const std::string &GeneratorProfile::cothString() const { return mPimpl->mCothString; } @@ -1526,7 +1526,7 @@ void GeneratorProfile::setCothString(const std::string &cothString) mPimpl->mCothString = cothString; } -std::string GeneratorProfile::asinString() const +const std::string &GeneratorProfile::asinString() const { return mPimpl->mAsinString; } @@ -1536,7 +1536,7 @@ void GeneratorProfile::setAsinString(const std::string &asinString) mPimpl->mAsinString = asinString; } -std::string GeneratorProfile::acosString() const +const std::string &GeneratorProfile::acosString() const { return mPimpl->mAcosString; } @@ -1546,7 +1546,7 @@ void GeneratorProfile::setAcosString(const std::string &acosString) mPimpl->mAcosString = acosString; } -std::string GeneratorProfile::atanString() const +const std::string &GeneratorProfile::atanString() const { return mPimpl->mAtanString; } @@ -1556,7 +1556,7 @@ void GeneratorProfile::setAtanString(const std::string &atanString) mPimpl->mAtanString = atanString; } -std::string GeneratorProfile::asecString() const +const std::string &GeneratorProfile::asecString() const { return mPimpl->mAsecString; } @@ -1566,7 +1566,7 @@ void GeneratorProfile::setAsecString(const std::string &asecString) mPimpl->mAsecString = asecString; } -std::string GeneratorProfile::acscString() const +const std::string &GeneratorProfile::acscString() const { return mPimpl->mAcscString; } @@ -1576,7 +1576,7 @@ void GeneratorProfile::setAcscString(const std::string &acscString) mPimpl->mAcscString = acscString; } -std::string GeneratorProfile::acotString() const +const std::string &GeneratorProfile::acotString() const { return mPimpl->mAcotString; } @@ -1586,7 +1586,7 @@ void GeneratorProfile::setAcotString(const std::string &acotString) mPimpl->mAcotString = acotString; } -std::string GeneratorProfile::asinhString() const +const std::string &GeneratorProfile::asinhString() const { return mPimpl->mAsinhString; } @@ -1596,7 +1596,7 @@ void GeneratorProfile::setAsinhString(const std::string &asinhString) mPimpl->mAsinhString = asinhString; } -std::string GeneratorProfile::acoshString() const +const std::string &GeneratorProfile::acoshString() const { return mPimpl->mAcoshString; } @@ -1606,7 +1606,7 @@ void GeneratorProfile::setAcoshString(const std::string &acoshString) mPimpl->mAcoshString = acoshString; } -std::string GeneratorProfile::atanhString() const +const std::string &GeneratorProfile::atanhString() const { return mPimpl->mAtanhString; } @@ -1616,7 +1616,7 @@ void GeneratorProfile::setAtanhString(const std::string &atanhString) mPimpl->mAtanhString = atanhString; } -std::string GeneratorProfile::asechString() const +const std::string &GeneratorProfile::asechString() const { return mPimpl->mAsechString; } @@ -1626,7 +1626,7 @@ void GeneratorProfile::setAsechString(const std::string &asechString) mPimpl->mAsechString = asechString; } -std::string GeneratorProfile::acschString() const +const std::string &GeneratorProfile::acschString() const { return mPimpl->mAcschString; } @@ -1636,7 +1636,7 @@ void GeneratorProfile::setAcschString(const std::string &acschString) mPimpl->mAcschString = acschString; } -std::string GeneratorProfile::acothString() const +const std::string &GeneratorProfile::acothString() const { return mPimpl->mAcothString; } @@ -1646,7 +1646,7 @@ void GeneratorProfile::setAcothString(const std::string &acothString) mPimpl->mAcothString = acothString; } -std::string GeneratorProfile::conditionalOperatorIfString() const +const std::string &GeneratorProfile::conditionalOperatorIfString() const { return mPimpl->mConditionalOperatorIfString; } @@ -1656,7 +1656,7 @@ void GeneratorProfile::setConditionalOperatorIfString(const std::string &conditi mPimpl->mConditionalOperatorIfString = conditionalOperatorIfString; } -std::string GeneratorProfile::conditionalOperatorElseString() const +const std::string &GeneratorProfile::conditionalOperatorElseString() const { return mPimpl->mConditionalOperatorElseString; } @@ -1666,7 +1666,7 @@ void GeneratorProfile::setConditionalOperatorElseString(const std::string &condi mPimpl->mConditionalOperatorElseString = conditionalOperatorElseString; } -std::string GeneratorProfile::piecewiseIfString() const +const std::string &GeneratorProfile::piecewiseIfString() const { return mPimpl->mPiecewiseIfString; } @@ -1676,7 +1676,7 @@ void GeneratorProfile::setPiecewiseIfString(const std::string &piecewiseIfString mPimpl->mPiecewiseIfString = piecewiseIfString; } -std::string GeneratorProfile::piecewiseElseString() const +const std::string &GeneratorProfile::piecewiseElseString() const { return mPimpl->mPiecewiseElseString; } @@ -1696,7 +1696,7 @@ void GeneratorProfile::setHasConditionalOperator(bool hasConditionalOperator) mPimpl->mHasConditionalOperator = hasConditionalOperator; } -std::string GeneratorProfile::trueString() const +const std::string &GeneratorProfile::trueString() const { return mPimpl->mTrueString; } @@ -1706,7 +1706,7 @@ void GeneratorProfile::setTrueString(const std::string &trueString) mPimpl->mTrueString = trueString; } -std::string GeneratorProfile::falseString() const +const std::string &GeneratorProfile::falseString() const { return mPimpl->mFalseString; } @@ -1716,7 +1716,7 @@ void GeneratorProfile::setFalseString(const std::string &falseString) mPimpl->mFalseString = falseString; } -std::string GeneratorProfile::eString() const +const std::string &GeneratorProfile::eString() const { return mPimpl->mEString; } @@ -1726,7 +1726,7 @@ void GeneratorProfile::setEString(const std::string &eString) mPimpl->mEString = eString; } -std::string GeneratorProfile::piString() const +const std::string &GeneratorProfile::piString() const { return mPimpl->mPiString; } @@ -1736,7 +1736,7 @@ void GeneratorProfile::setPiString(const std::string &piString) mPimpl->mPiString = piString; } -std::string GeneratorProfile::infString() const +const std::string &GeneratorProfile::infString() const { return mPimpl->mInfString; } @@ -1746,7 +1746,7 @@ void GeneratorProfile::setInfString(const std::string &infString) mPimpl->mInfString = infString; } -std::string GeneratorProfile::nanString() const +const std::string &GeneratorProfile::nanString() const { return mPimpl->mNanString; } @@ -1756,7 +1756,7 @@ void GeneratorProfile::setNanString(const std::string &nanString) mPimpl->mNanString = nanString; } -std::string GeneratorProfile::eqFunctionString() const +const std::string &GeneratorProfile::eqFunctionString() const { return mPimpl->mEqFunctionString; } @@ -1766,7 +1766,7 @@ void GeneratorProfile::setEqFunctionString(const std::string &eqFunctionString) mPimpl->mEqFunctionString = eqFunctionString; } -std::string GeneratorProfile::neqFunctionString() const +const std::string &GeneratorProfile::neqFunctionString() const { return mPimpl->mNeqFunctionString; } @@ -1776,7 +1776,7 @@ void GeneratorProfile::setNeqFunctionString(const std::string &neqFunctionString mPimpl->mNeqFunctionString = neqFunctionString; } -std::string GeneratorProfile::ltFunctionString() const +const std::string &GeneratorProfile::ltFunctionString() const { return mPimpl->mLtFunctionString; } @@ -1786,7 +1786,7 @@ void GeneratorProfile::setLtFunctionString(const std::string <FunctionString) mPimpl->mLtFunctionString = ltFunctionString; } -std::string GeneratorProfile::leqFunctionString() const +const std::string &GeneratorProfile::leqFunctionString() const { return mPimpl->mLeqFunctionString; } @@ -1796,7 +1796,7 @@ void GeneratorProfile::setLeqFunctionString(const std::string &leqFunctionString mPimpl->mLeqFunctionString = leqFunctionString; } -std::string GeneratorProfile::gtFunctionString() const +const std::string &GeneratorProfile::gtFunctionString() const { return mPimpl->mGtFunctionString; } @@ -1806,7 +1806,7 @@ void GeneratorProfile::setGtFunctionString(const std::string >FunctionString) mPimpl->mGtFunctionString = gtFunctionString; } -std::string GeneratorProfile::geqFunctionString() const +const std::string &GeneratorProfile::geqFunctionString() const { return mPimpl->mGeqFunctionString; } @@ -1816,7 +1816,7 @@ void GeneratorProfile::setGeqFunctionString(const std::string &geqFunctionString mPimpl->mGeqFunctionString = geqFunctionString; } -std::string GeneratorProfile::andFunctionString() const +const std::string &GeneratorProfile::andFunctionString() const { return mPimpl->mAndFunctionString; } @@ -1826,7 +1826,7 @@ void GeneratorProfile::setAndFunctionString(const std::string &andFunctionString mPimpl->mAndFunctionString = andFunctionString; } -std::string GeneratorProfile::orFunctionString() const +const std::string &GeneratorProfile::orFunctionString() const { return mPimpl->mOrFunctionString; } @@ -1836,7 +1836,7 @@ void GeneratorProfile::setOrFunctionString(const std::string &orFunctionString) mPimpl->mOrFunctionString = orFunctionString; } -std::string GeneratorProfile::xorFunctionString() const +const std::string &GeneratorProfile::xorFunctionString() const { return mPimpl->mXorFunctionString; } @@ -1846,7 +1846,7 @@ void GeneratorProfile::setXorFunctionString(const std::string &xorFunctionString mPimpl->mXorFunctionString = xorFunctionString; } -std::string GeneratorProfile::notFunctionString() const +const std::string &GeneratorProfile::notFunctionString() const { return mPimpl->mNotFunctionString; } @@ -1856,7 +1856,7 @@ void GeneratorProfile::setNotFunctionString(const std::string ¬FunctionString mPimpl->mNotFunctionString = notFunctionString; } -std::string GeneratorProfile::minFunctionString() const +const std::string &GeneratorProfile::minFunctionString() const { return mPimpl->mMinFunctionString; } @@ -1866,7 +1866,7 @@ void GeneratorProfile::setMinFunctionString(const std::string &minFunctionString mPimpl->mMinFunctionString = minFunctionString; } -std::string GeneratorProfile::maxFunctionString() const +const std::string &GeneratorProfile::maxFunctionString() const { return mPimpl->mMaxFunctionString; } @@ -1876,7 +1876,7 @@ void GeneratorProfile::setMaxFunctionString(const std::string &maxFunctionString mPimpl->mMaxFunctionString = maxFunctionString; } -std::string GeneratorProfile::secFunctionString() const +const std::string &GeneratorProfile::secFunctionString() const { return mPimpl->mSecFunctionString; } @@ -1886,7 +1886,7 @@ void GeneratorProfile::setSecFunctionString(const std::string &secFunctionString mPimpl->mSecFunctionString = secFunctionString; } -std::string GeneratorProfile::cscFunctionString() const +const std::string &GeneratorProfile::cscFunctionString() const { return mPimpl->mCscFunctionString; } @@ -1896,7 +1896,7 @@ void GeneratorProfile::setCscFunctionString(const std::string &cscFunctionString mPimpl->mCscFunctionString = cscFunctionString; } -std::string GeneratorProfile::cotFunctionString() const +const std::string &GeneratorProfile::cotFunctionString() const { return mPimpl->mCotFunctionString; } @@ -1906,7 +1906,7 @@ void GeneratorProfile::setCotFunctionString(const std::string &cotFunctionString mPimpl->mCotFunctionString = cotFunctionString; } -std::string GeneratorProfile::sechFunctionString() const +const std::string &GeneratorProfile::sechFunctionString() const { return mPimpl->mSechFunctionString; } @@ -1916,7 +1916,7 @@ void GeneratorProfile::setSechFunctionString(const std::string &sechFunctionStri mPimpl->mSechFunctionString = sechFunctionString; } -std::string GeneratorProfile::cschFunctionString() const +const std::string &GeneratorProfile::cschFunctionString() const { return mPimpl->mCschFunctionString; } @@ -1926,7 +1926,7 @@ void GeneratorProfile::setCschFunctionString(const std::string &cschFunctionStri mPimpl->mCschFunctionString = cschFunctionString; } -std::string GeneratorProfile::cothFunctionString() const +const std::string &GeneratorProfile::cothFunctionString() const { return mPimpl->mCothFunctionString; } @@ -1936,7 +1936,7 @@ void GeneratorProfile::setCothFunctionString(const std::string &cothFunctionStri mPimpl->mCothFunctionString = cothFunctionString; } -std::string GeneratorProfile::asecFunctionString() const +const std::string &GeneratorProfile::asecFunctionString() const { return mPimpl->mAsecFunctionString; } @@ -1946,7 +1946,7 @@ void GeneratorProfile::setAsecFunctionString(const std::string &asecFunctionStri mPimpl->mAsecFunctionString = asecFunctionString; } -std::string GeneratorProfile::acscFunctionString() const +const std::string &GeneratorProfile::acscFunctionString() const { return mPimpl->mAcscFunctionString; } @@ -1956,7 +1956,7 @@ void GeneratorProfile::setAcscFunctionString(const std::string &acscFunctionStri mPimpl->mAcscFunctionString = acscFunctionString; } -std::string GeneratorProfile::acotFunctionString() const +const std::string &GeneratorProfile::acotFunctionString() const { return mPimpl->mAcotFunctionString; } @@ -1966,7 +1966,7 @@ void GeneratorProfile::setAcotFunctionString(const std::string &acotFunctionStri mPimpl->mAcotFunctionString = acotFunctionString; } -std::string GeneratorProfile::asechFunctionString() const +const std::string &GeneratorProfile::asechFunctionString() const { return mPimpl->mAsechFunctionString; } @@ -1976,7 +1976,7 @@ void GeneratorProfile::setAsechFunctionString(const std::string &asechFunctionSt mPimpl->mAsechFunctionString = asechFunctionString; } -std::string GeneratorProfile::acschFunctionString() const +const std::string &GeneratorProfile::acschFunctionString() const { return mPimpl->mAcschFunctionString; } @@ -1986,7 +1986,7 @@ void GeneratorProfile::setAcschFunctionString(const std::string &acschFunctionSt mPimpl->mAcschFunctionString = acschFunctionString; } -std::string GeneratorProfile::acothFunctionString() const +const std::string &GeneratorProfile::acothFunctionString() const { return mPimpl->mAcothFunctionString; } @@ -1996,7 +1996,7 @@ void GeneratorProfile::setAcothFunctionString(const std::string &acothFunctionSt mPimpl->mAcothFunctionString = acothFunctionString; } -std::string GeneratorProfile::commentString() const +const std::string &GeneratorProfile::commentString() const { return mPimpl->mCommentString; } @@ -2006,7 +2006,7 @@ void GeneratorProfile::setCommentString(const std::string &commentString) mPimpl->mCommentString = commentString; } -std::string GeneratorProfile::originCommentString() const +const std::string &GeneratorProfile::originCommentString() const { return mPimpl->mOriginCommentString; } @@ -2016,7 +2016,7 @@ void GeneratorProfile::setOriginCommentString(const std::string &originCommentSt mPimpl->mOriginCommentString = originCommentString; } -std::string GeneratorProfile::interfaceFileNameString() const +const std::string &GeneratorProfile::interfaceFileNameString() const { return mPimpl->mInterfaceFileNameString; } @@ -2026,7 +2026,7 @@ void GeneratorProfile::setInterfaceFileNameString(const std::string &interfaceFi mPimpl->mInterfaceFileNameString = interfaceFileNameString; } -std::string GeneratorProfile::interfaceHeaderString() const +const std::string &GeneratorProfile::interfaceHeaderString() const { return mPimpl->mInterfaceHeaderString; } @@ -2036,7 +2036,7 @@ void GeneratorProfile::setInterfaceHeaderString(const std::string &interfaceHead mPimpl->mInterfaceHeaderString = interfaceHeaderString; } -std::string GeneratorProfile::implementationHeaderString() const +const std::string &GeneratorProfile::implementationHeaderString() const { return mPimpl->mImplementationHeaderString; } @@ -2046,7 +2046,7 @@ void GeneratorProfile::setImplementationHeaderString(const std::string &implemen mPimpl->mImplementationHeaderString = implementationHeaderString; } -std::string GeneratorProfile::interfaceVersionString() const +const std::string &GeneratorProfile::interfaceVersionString() const { return mPimpl->mInterfaceVersionString; } @@ -2056,7 +2056,7 @@ void GeneratorProfile::setInterfaceVersionString(const std::string &interfaceVer mPimpl->mInterfaceVersionString = interfaceVersionString; } -std::string GeneratorProfile::implementationVersionString() const +const std::string &GeneratorProfile::implementationVersionString() const { return mPimpl->mImplementationVersionString; } @@ -2066,7 +2066,7 @@ void GeneratorProfile::setImplementationVersionString(const std::string &impleme mPimpl->mImplementationVersionString = implementationVersionString; } -std::string GeneratorProfile::interfaceLibcellmlVersionString() const +const std::string &GeneratorProfile::interfaceLibcellmlVersionString() const { return mPimpl->mInterfaceLibcellmlVersionString; } @@ -2076,7 +2076,7 @@ void GeneratorProfile::setInterfaceLibcellmlVersionString(const std::string &int mPimpl->mInterfaceLibcellmlVersionString = interfaceLibcellmlVersionString; } -std::string GeneratorProfile::implementationLibcellmlVersionString() const +const std::string &GeneratorProfile::implementationLibcellmlVersionString() const { return mPimpl->mImplementationLibcellmlVersionString; } @@ -2086,7 +2086,7 @@ void GeneratorProfile::setImplementationLibcellmlVersionString(const std::string mPimpl->mImplementationLibcellmlVersionString = implementationLibcellmlVersionString; } -std::string GeneratorProfile::interfaceStateCountString() const +const std::string &GeneratorProfile::interfaceStateCountString() const { return mPimpl->mInterfaceStateCountString; } @@ -2096,7 +2096,7 @@ void GeneratorProfile::setInterfaceStateCountString(const std::string &interface mPimpl->mInterfaceStateCountString = interfaceStateCountString; } -std::string GeneratorProfile::implementationStateCountString() const +const std::string &GeneratorProfile::implementationStateCountString() const { return mPimpl->mImplementationStateCountString; } @@ -2106,7 +2106,7 @@ void GeneratorProfile::setImplementationStateCountString(const std::string &impl mPimpl->mImplementationStateCountString = implementationStateCountString; } -std::string GeneratorProfile::interfaceConstantCountString() const +const std::string &GeneratorProfile::interfaceConstantCountString() const { return mPimpl->mInterfaceConstantCountString; } @@ -2116,7 +2116,7 @@ void GeneratorProfile::setInterfaceConstantCountString(const std::string &interf mPimpl->mInterfaceConstantCountString = interfaceConstantCountString; } -std::string GeneratorProfile::implementationConstantCountString() const +const std::string &GeneratorProfile::implementationConstantCountString() const { return mPimpl->mImplementationConstantCountString; } @@ -2126,7 +2126,7 @@ void GeneratorProfile::setImplementationConstantCountString(const std::string &i mPimpl->mImplementationConstantCountString = implementationConstantCountString; } -std::string GeneratorProfile::interfaceComputedConstantCountString() const +const std::string &GeneratorProfile::interfaceComputedConstantCountString() const { return mPimpl->mInterfaceComputedConstantCountString; } @@ -2136,7 +2136,7 @@ void GeneratorProfile::setInterfaceComputedConstantCountString(const std::string mPimpl->mInterfaceComputedConstantCountString = interfaceComputedConstantCountString; } -std::string GeneratorProfile::implementationComputedConstantCountString() const +const std::string &GeneratorProfile::implementationComputedConstantCountString() const { return mPimpl->mImplementationComputedConstantCountString; } @@ -2146,7 +2146,7 @@ void GeneratorProfile::setImplementationComputedConstantCountString(const std::s mPimpl->mImplementationComputedConstantCountString = implementationComputedConstantCountString; } -std::string GeneratorProfile::interfaceAlgebraicVariableCountString() const +const std::string &GeneratorProfile::interfaceAlgebraicVariableCountString() const { return mPimpl->mInterfaceAlgebraicVariableCountString; } @@ -2156,7 +2156,7 @@ void GeneratorProfile::setInterfaceAlgebraicVariableCountString(const std::strin mPimpl->mInterfaceAlgebraicVariableCountString = interfaceAlgebraicVariableCountString; } -std::string GeneratorProfile::implementationAlgebraicVariableCountString() const +const std::string &GeneratorProfile::implementationAlgebraicVariableCountString() const { return mPimpl->mImplementationAlgebraicVariableCountString; } @@ -2166,7 +2166,7 @@ void GeneratorProfile::setImplementationAlgebraicVariableCountString(const std:: mPimpl->mImplementationAlgebraicVariableCountString = implementationAlgebraicVariableCountString; } -std::string GeneratorProfile::interfaceExternalVariableCountString() const +const std::string &GeneratorProfile::interfaceExternalVariableCountString() const { return mPimpl->mInterfaceExternalVariableCountString; } @@ -2176,7 +2176,7 @@ void GeneratorProfile::setInterfaceExternalVariableCountString(const std::string mPimpl->mInterfaceExternalVariableCountString = interfaceExternalVariableCountString; } -std::string GeneratorProfile::implementationExternalVariableCountString() const +const std::string &GeneratorProfile::implementationExternalVariableCountString() const { return mPimpl->mImplementationExternalVariableCountString; } @@ -2186,7 +2186,7 @@ void GeneratorProfile::setImplementationExternalVariableCountString(const std::s mPimpl->mImplementationExternalVariableCountString = implementationExternalVariableCountString; } -std::string GeneratorProfile::variableInfoObjectString() const +const std::string &GeneratorProfile::variableInfoObjectString() const { return mPimpl->mVariableInfoObjectString; } @@ -2196,7 +2196,7 @@ void GeneratorProfile::setVariableInfoObjectString(const std::string &variableIn mPimpl->mVariableInfoObjectString = variableInfoObjectString; } -std::string GeneratorProfile::interfaceVoiInfoString() const +const std::string &GeneratorProfile::interfaceVoiInfoString() const { return mPimpl->mInterfaceVoiInfoString; } @@ -2206,7 +2206,7 @@ void GeneratorProfile::setInterfaceVoiInfoString(const std::string &interfaceVoi mPimpl->mInterfaceVoiInfoString = interfaceVoiInfoString; } -std::string GeneratorProfile::implementationVoiInfoString() const +const std::string &GeneratorProfile::implementationVoiInfoString() const { return mPimpl->mImplementationVoiInfoString; } @@ -2216,7 +2216,7 @@ void GeneratorProfile::setImplementationVoiInfoString(const std::string &impleme mPimpl->mImplementationVoiInfoString = implementationVoiInfoString; } -std::string GeneratorProfile::interfaceStateInfoString() const +const std::string &GeneratorProfile::interfaceStateInfoString() const { return mPimpl->mInterfaceStateInfoString; } @@ -2226,7 +2226,7 @@ void GeneratorProfile::setInterfaceStateInfoString(const std::string &interfaceS mPimpl->mInterfaceStateInfoString = interfaceStateInfoString; } -std::string GeneratorProfile::implementationStateInfoString() const +const std::string &GeneratorProfile::implementationStateInfoString() const { return mPimpl->mImplementationStateInfoString; } @@ -2236,7 +2236,7 @@ void GeneratorProfile::setImplementationStateInfoString(const std::string &imple mPimpl->mImplementationStateInfoString = implementationStateInfoString; } -std::string GeneratorProfile::interfaceConstantInfoString() const +const std::string &GeneratorProfile::interfaceConstantInfoString() const { return mPimpl->mInterfaceConstantInfoString; } @@ -2246,7 +2246,7 @@ void GeneratorProfile::setInterfaceConstantInfoString(const std::string &interfa mPimpl->mInterfaceConstantInfoString = interfaceConstantInfoString; } -std::string GeneratorProfile::implementationConstantInfoString() const +const std::string &GeneratorProfile::implementationConstantInfoString() const { return mPimpl->mImplementationConstantInfoString; } @@ -2256,7 +2256,7 @@ void GeneratorProfile::setImplementationConstantInfoString(const std::string &im mPimpl->mImplementationConstantInfoString = implementationConstantInfoString; } -std::string GeneratorProfile::interfaceComputedConstantInfoString() const +const std::string &GeneratorProfile::interfaceComputedConstantInfoString() const { return mPimpl->mInterfaceComputedConstantInfoString; } @@ -2266,7 +2266,7 @@ void GeneratorProfile::setInterfaceComputedConstantInfoString(const std::string mPimpl->mInterfaceComputedConstantInfoString = interfaceComputedConstantInfoString; } -std::string GeneratorProfile::implementationComputedConstantInfoString() const +const std::string &GeneratorProfile::implementationComputedConstantInfoString() const { return mPimpl->mImplementationComputedConstantInfoString; } @@ -2276,7 +2276,7 @@ void GeneratorProfile::setImplementationComputedConstantInfoString(const std::st mPimpl->mImplementationComputedConstantInfoString = implementationComputedConstantInfoString; } -std::string GeneratorProfile::interfaceAlgebraicVariableInfoString() const +const std::string &GeneratorProfile::interfaceAlgebraicVariableInfoString() const { return mPimpl->mInterfaceAlgebraicVariableInfoString; } @@ -2286,7 +2286,7 @@ void GeneratorProfile::setInterfaceAlgebraicVariableInfoString(const std::string mPimpl->mInterfaceAlgebraicVariableInfoString = interfaceAlgebraicVariableInfoString; } -std::string GeneratorProfile::implementationAlgebraicVariableInfoString() const +const std::string &GeneratorProfile::implementationAlgebraicVariableInfoString() const { return mPimpl->mImplementationAlgebraicVariableInfoString; } @@ -2296,7 +2296,7 @@ void GeneratorProfile::setImplementationAlgebraicVariableInfoString(const std::s mPimpl->mImplementationAlgebraicVariableInfoString = implementationAlgebraicVariableInfoString; } -std::string GeneratorProfile::interfaceExternalVariableInfoString() const +const std::string &GeneratorProfile::interfaceExternalVariableInfoString() const { return mPimpl->mInterfaceExternalVariableInfoString; } @@ -2306,7 +2306,7 @@ void GeneratorProfile::setInterfaceExternalVariableInfoString(const std::string mPimpl->mInterfaceExternalVariableInfoString = interfaceExternalVariableInfoString; } -std::string GeneratorProfile::implementationExternalVariableInfoString() const +const std::string &GeneratorProfile::implementationExternalVariableInfoString() const { return mPimpl->mImplementationExternalVariableInfoString; } @@ -2316,7 +2316,7 @@ void GeneratorProfile::setImplementationExternalVariableInfoString(const std::st mPimpl->mImplementationExternalVariableInfoString = implementationExternalVariableInfoString; } -std::string GeneratorProfile::variableInfoEntryString() const +const std::string &GeneratorProfile::variableInfoEntryString() const { return mPimpl->mVariableInfoEntryString; } @@ -2326,7 +2326,7 @@ void GeneratorProfile::setVariableInfoEntryString(const std::string &variableInf mPimpl->mVariableInfoEntryString = variableInfoEntryString; } -std::string GeneratorProfile::voiString() const +const std::string &GeneratorProfile::voiString() const { return mPimpl->mVoiString; } @@ -2336,7 +2336,7 @@ void GeneratorProfile::setVoiString(const std::string &voiString) mPimpl->mVoiString = voiString; } -std::string GeneratorProfile::statesArrayString() const +const std::string &GeneratorProfile::statesArrayString() const { return mPimpl->mStatesArrayString; } @@ -2346,7 +2346,7 @@ void GeneratorProfile::setStatesArrayString(const std::string &statesArrayString mPimpl->mStatesArrayString = statesArrayString; } -std::string GeneratorProfile::ratesArrayString() const +const std::string &GeneratorProfile::ratesArrayString() const { return mPimpl->mRatesArrayString; } @@ -2356,7 +2356,7 @@ void GeneratorProfile::setRatesArrayString(const std::string &ratesArrayString) mPimpl->mRatesArrayString = ratesArrayString; } -std::string GeneratorProfile::constantsArrayString() const +const std::string &GeneratorProfile::constantsArrayString() const { return mPimpl->mConstantsArrayString; } @@ -2366,7 +2366,7 @@ void GeneratorProfile::setConstantsArrayString(const std::string &constantsArray mPimpl->mConstantsArrayString = constantsArrayString; } -std::string GeneratorProfile::computedConstantsArrayString() const +const std::string &GeneratorProfile::computedConstantsArrayString() const { return mPimpl->mComputedConstantsArrayString; } @@ -2376,7 +2376,7 @@ void GeneratorProfile::setComputedConstantsArrayString(const std::string &comput mPimpl->mComputedConstantsArrayString = computedConstantsArrayString; } -std::string GeneratorProfile::algebraicVariablesArrayString() const +const std::string &GeneratorProfile::algebraicVariablesArrayString() const { return mPimpl->mAlgebraicVariablesArrayString; } @@ -2386,7 +2386,7 @@ void GeneratorProfile::setAlgebraicVariablesArrayString(const std::string &algeb mPimpl->mAlgebraicVariablesArrayString = algebraicVariablesArrayString; } -std::string GeneratorProfile::externalVariablesArrayString() const +const std::string &GeneratorProfile::externalVariablesArrayString() const { return mPimpl->mExternalVariablesArrayString; } @@ -2396,7 +2396,7 @@ void GeneratorProfile::setExternalVariablesArrayString(const std::string &extern mPimpl->mExternalVariablesArrayString = externalVariablesArrayString; } -std::string GeneratorProfile::externalVariableMethodTypeDefinitionString(bool forDifferentialModel) const +const std::string &GeneratorProfile::externalVariableMethodTypeDefinitionString(bool forDifferentialModel) const { if (forDifferentialModel) { return mPimpl->mExternalVariableMethodTypeDefinitionDiffString; @@ -2415,7 +2415,7 @@ void GeneratorProfile::setExternalVariableMethodTypeDefinitionString(bool forDif } } -std::string GeneratorProfile::externalVariableMethodCallString(bool forDifferentialModel) const +const std::string &GeneratorProfile::externalVariableMethodCallString(bool forDifferentialModel) const { if (forDifferentialModel) { return mPimpl->mExternalVariableMethodCallDiffString; @@ -2434,8 +2434,8 @@ void GeneratorProfile::setExternalVariableMethodCallString(bool forDifferentialM } } -std::string GeneratorProfile::rootFindingInfoObjectString(bool forDifferentialModel, - bool withExternalVariables) const +const std::string &GeneratorProfile::rootFindingInfoObjectString(bool forDifferentialModel, + bool withExternalVariables) const { if (forDifferentialModel) { if (withExternalVariables) { @@ -2471,7 +2471,7 @@ void GeneratorProfile::setRootFindingInfoObjectString(bool forDifferentialModel, } } -std::string GeneratorProfile::externNlaSolveMethodString() const +const std::string &GeneratorProfile::externNlaSolveMethodString() const { return mPimpl->mExternNlaSolveMethodString; } @@ -2481,8 +2481,8 @@ void GeneratorProfile::setExternNlaSolveMethodString(const std::string &externNl mPimpl->mExternNlaSolveMethodString = externNlaSolveMethodString; } -std::string GeneratorProfile::findRootCallString(bool forDifferentialModel, - bool withExternalVariables) const +const std::string &GeneratorProfile::findRootCallString(bool forDifferentialModel, + bool withExternalVariables) const { if (forDifferentialModel) { if (withExternalVariables) { @@ -2518,8 +2518,8 @@ void GeneratorProfile::setFindRootCallString(bool forDifferentialModel, } } -std::string GeneratorProfile::findRootMethodString(bool forDifferentialModel, - bool withExternalVariables) const +const std::string &GeneratorProfile::findRootMethodString(bool forDifferentialModel, + bool withExternalVariables) const { if (forDifferentialModel) { if (withExternalVariables) { @@ -2555,8 +2555,8 @@ void GeneratorProfile::setFindRootMethodString(bool forDifferentialModel, } } -std::string GeneratorProfile::nlaSolveCallString(bool forDifferentialModel, - bool withExternalVariables) const +const std::string &GeneratorProfile::nlaSolveCallString(bool forDifferentialModel, + bool withExternalVariables) const { if (forDifferentialModel) { if (withExternalVariables) { @@ -2592,8 +2592,8 @@ void GeneratorProfile::setNlaSolveCallString(bool forDifferentialModel, } } -std::string GeneratorProfile::objectiveFunctionMethodString(bool forDifferentialModel, - bool withExternalVariables) const +const std::string &GeneratorProfile::objectiveFunctionMethodString(bool forDifferentialModel, + bool withExternalVariables) const { if (forDifferentialModel) { if (withExternalVariables) { @@ -2629,7 +2629,7 @@ void GeneratorProfile::setObjectiveFunctionMethodString(bool forDifferentialMode } } -std::string GeneratorProfile::uArrayString() const +const std::string &GeneratorProfile::uArrayString() const { return mPimpl->mUArrayString; } @@ -2639,7 +2639,7 @@ void GeneratorProfile::setUArrayString(const std::string &uArrayString) mPimpl->mUArrayString = uArrayString; } -std::string GeneratorProfile::fArrayString() const +const std::string &GeneratorProfile::fArrayString() const { return mPimpl->mFArrayString; } @@ -2649,7 +2649,7 @@ void GeneratorProfile::setFArrayString(const std::string &fArrayString) mPimpl->mFArrayString = fArrayString; } -std::string GeneratorProfile::interfaceCreateStatesArrayMethodString() const +const std::string &GeneratorProfile::interfaceCreateStatesArrayMethodString() const { return mPimpl->mInterfaceCreateStatesArrayMethodString; } @@ -2659,7 +2659,7 @@ void GeneratorProfile::setInterfaceCreateStatesArrayMethodString(const std::stri mPimpl->mInterfaceCreateStatesArrayMethodString = interfaceCreateStatesArrayMethodString; } -std::string GeneratorProfile::implementationCreateStatesArrayMethodString() const +const std::string &GeneratorProfile::implementationCreateStatesArrayMethodString() const { return mPimpl->mImplementationCreateStatesArrayMethodString; } @@ -2669,7 +2669,7 @@ void GeneratorProfile::setImplementationCreateStatesArrayMethodString(const std: mPimpl->mImplementationCreateStatesArrayMethodString = implementationCreateStatesArrayMethodString; } -std::string GeneratorProfile::interfaceCreateConstantsArrayMethodString() const +const std::string &GeneratorProfile::interfaceCreateConstantsArrayMethodString() const { return mPimpl->mInterfaceCreateConstantsArrayMethodString; } @@ -2679,7 +2679,7 @@ void GeneratorProfile::setInterfaceCreateConstantsArrayMethodString(const std::s mPimpl->mInterfaceCreateConstantsArrayMethodString = interfaceCreateConstantsArrayMethodString; } -std::string GeneratorProfile::implementationCreateConstantsArrayMethodString() const +const std::string &GeneratorProfile::implementationCreateConstantsArrayMethodString() const { return mPimpl->mImplementationCreateConstantsArrayMethodString; } @@ -2689,7 +2689,7 @@ void GeneratorProfile::setImplementationCreateConstantsArrayMethodString(const s mPimpl->mImplementationCreateConstantsArrayMethodString = implementationCreateConstantsArrayMethodString; } -std::string GeneratorProfile::interfaceCreateComputedConstantsArrayMethodString() const +const std::string &GeneratorProfile::interfaceCreateComputedConstantsArrayMethodString() const { return mPimpl->mInterfaceCreateComputedConstantsArrayMethodString; } @@ -2699,7 +2699,7 @@ void GeneratorProfile::setInterfaceCreateComputedConstantsArrayMethodString(cons mPimpl->mInterfaceCreateComputedConstantsArrayMethodString = interfaceCreateComputedConstantsArrayMethodString; } -std::string GeneratorProfile::implementationCreateComputedConstantsArrayMethodString() const +const std::string &GeneratorProfile::implementationCreateComputedConstantsArrayMethodString() const { return mPimpl->mImplementationCreateComputedConstantsArrayMethodString; } @@ -2709,7 +2709,7 @@ void GeneratorProfile::setImplementationCreateComputedConstantsArrayMethodString mPimpl->mImplementationCreateComputedConstantsArrayMethodString = implementationCreateComputedConstantsArrayMethodString; } -std::string GeneratorProfile::interfaceCreateAlgebraicVariablesArrayMethodString() const +const std::string &GeneratorProfile::interfaceCreateAlgebraicVariablesArrayMethodString() const { return mPimpl->mInterfaceCreateAlgebraicVariablesArrayMethodString; } @@ -2719,7 +2719,7 @@ void GeneratorProfile::setInterfaceCreateAlgebraicVariablesArrayMethodString(con mPimpl->mInterfaceCreateAlgebraicVariablesArrayMethodString = interfaceCreateAlgebraicVariablesArrayMethodString; } -std::string GeneratorProfile::implementationCreateAlgebraicVariablesArrayMethodString() const +const std::string &GeneratorProfile::implementationCreateAlgebraicVariablesArrayMethodString() const { return mPimpl->mImplementationCreateAlgebraicVariablesArrayMethodString; } @@ -2729,7 +2729,7 @@ void GeneratorProfile::setImplementationCreateAlgebraicVariablesArrayMethodStrin mPimpl->mImplementationCreateAlgebraicVariablesArrayMethodString = implementationCreateAlgebraicVariablesArrayMethodString; } -std::string GeneratorProfile::interfaceCreateExternalVariablesArrayMethodString() const +const std::string &GeneratorProfile::interfaceCreateExternalVariablesArrayMethodString() const { return mPimpl->mInterfaceCreateExternalVariablesArrayMethodString; } @@ -2739,7 +2739,7 @@ void GeneratorProfile::setInterfaceCreateExternalVariablesArrayMethodString(cons mPimpl->mInterfaceCreateExternalVariablesArrayMethodString = interfaceCreateExternalVariablesArrayMethodString; } -std::string GeneratorProfile::implementationCreateExternalVariablesArrayMethodString() const +const std::string &GeneratorProfile::implementationCreateExternalVariablesArrayMethodString() const { return mPimpl->mImplementationCreateExternalVariablesArrayMethodString; } @@ -2749,7 +2749,7 @@ void GeneratorProfile::setImplementationCreateExternalVariablesArrayMethodString mPimpl->mImplementationCreateExternalVariablesArrayMethodString = implementationCreateExternalVariablesArrayMethodString; } -std::string GeneratorProfile::interfaceDeleteArrayMethodString() const +const std::string &GeneratorProfile::interfaceDeleteArrayMethodString() const { return mPimpl->mInterfaceDeleteArrayMethodString; } @@ -2759,7 +2759,7 @@ void GeneratorProfile::setInterfaceDeleteArrayMethodString(const std::string &in mPimpl->mInterfaceDeleteArrayMethodString = interfaceDeleteArrayMethodString; } -std::string GeneratorProfile::implementationDeleteArrayMethodString() const +const std::string &GeneratorProfile::implementationDeleteArrayMethodString() const { return mPimpl->mImplementationDeleteArrayMethodString; } @@ -2769,7 +2769,7 @@ void GeneratorProfile::setImplementationDeleteArrayMethodString(const std::strin mPimpl->mImplementationDeleteArrayMethodString = implementationDeleteArrayMethodString; } -std::string GeneratorProfile::interfaceInitialiseArraysMethodString(bool forDifferentialModel) const +const std::string &GeneratorProfile::interfaceInitialiseArraysMethodString(bool forDifferentialModel) const { if (forDifferentialModel) { return mPimpl->mInterfaceInitialiseArraysMethodDiffString; @@ -2788,7 +2788,7 @@ void GeneratorProfile::setInterfaceInitialiseArraysMethodString(bool forDifferen } } -std::string GeneratorProfile::implementationInitialiseArraysMethodString(bool forDifferentialModel) const +const std::string &GeneratorProfile::implementationInitialiseArraysMethodString(bool forDifferentialModel) const { if (forDifferentialModel) { return mPimpl->mImplementationInitialiseArraysMethodDiffString; @@ -2807,7 +2807,7 @@ void GeneratorProfile::setImplementationInitialiseArraysMethodString(bool forDif } } -std::string GeneratorProfile::interfaceComputeComputedConstantsMethodString(bool forDifferentialModel) const +const std::string &GeneratorProfile::interfaceComputeComputedConstantsMethodString(bool forDifferentialModel) const { if (forDifferentialModel) { return mPimpl->mInterfaceComputeComputedConstantsMethodDiffString; @@ -2826,7 +2826,7 @@ void GeneratorProfile::setInterfaceComputeComputedConstantsMethodString(bool for } } -std::string GeneratorProfile::implementationComputeComputedConstantsMethodString(bool forDifferentialModel) const +const std::string &GeneratorProfile::implementationComputeComputedConstantsMethodString(bool forDifferentialModel) const { if (forDifferentialModel) { return mPimpl->mImplementationComputeComputedConstantsMethodDiffString; @@ -2845,7 +2845,7 @@ void GeneratorProfile::setImplementationComputeComputedConstantsMethodString(boo } } -std::string GeneratorProfile::interfaceComputeRatesMethodString(bool withExternalVariables) const +const std::string &GeneratorProfile::interfaceComputeRatesMethodString(bool withExternalVariables) const { if (withExternalVariables) { return mPimpl->mInterfaceComputeRatesMethodWevString; @@ -2864,7 +2864,7 @@ void GeneratorProfile::setInterfaceComputeRatesMethodString(bool withExternalVar } } -std::string GeneratorProfile::implementationComputeRatesMethodString(bool withExternalVariables) const +const std::string &GeneratorProfile::implementationComputeRatesMethodString(bool withExternalVariables) const { if (withExternalVariables) { return mPimpl->mImplementationComputeRatesMethodWevString; @@ -2883,8 +2883,8 @@ void GeneratorProfile::setImplementationComputeRatesMethodString(bool withExtern } } -std::string GeneratorProfile::interfaceComputeVariablesMethodString(bool forDifferentialModel, - bool withExternalVariables) const +const std::string &GeneratorProfile::interfaceComputeVariablesMethodString(bool forDifferentialModel, + bool withExternalVariables) const { if (forDifferentialModel) { if (withExternalVariables) { @@ -2920,8 +2920,8 @@ void GeneratorProfile::setInterfaceComputeVariablesMethodString(bool forDifferen } } -std::string GeneratorProfile::implementationComputeVariablesMethodString(bool forDifferentialModel, - bool withExternalVariables) const +const std::string &GeneratorProfile::implementationComputeVariablesMethodString(bool forDifferentialModel, + bool withExternalVariables) const { if (forDifferentialModel) { if (withExternalVariables) { @@ -2957,7 +2957,7 @@ void GeneratorProfile::setImplementationComputeVariablesMethodString(bool forDif } } -std::string GeneratorProfile::emptyMethodString() const +const std::string &GeneratorProfile::emptyMethodString() const { return mPimpl->mEmptyMethodString; } @@ -2967,7 +2967,7 @@ void GeneratorProfile::setEmptyMethodString(const std::string &emptyMethodString mPimpl->mEmptyMethodString = emptyMethodString; } -std::string GeneratorProfile::indentString() const +const std::string &GeneratorProfile::indentString() const { return mPimpl->mIndentString; } @@ -2977,7 +2977,7 @@ void GeneratorProfile::setIndentString(const std::string &indentString) mPimpl->mIndentString = indentString; } -std::string GeneratorProfile::variableDeclarationString() const +const std::string &GeneratorProfile::variableDeclarationString() const { return mPimpl->mVariableDeclarationString; } @@ -2987,7 +2987,7 @@ void GeneratorProfile::setVariableDeclarationString(const std::string &variableD mPimpl->mVariableDeclarationString = variableDeclarationString; } -std::string GeneratorProfile::openArrayString() const +const std::string &GeneratorProfile::openArrayString() const { return mPimpl->mOpenArrayString; } @@ -2997,7 +2997,7 @@ void GeneratorProfile::setOpenArrayString(const std::string &openArrayString) mPimpl->mOpenArrayString = openArrayString; } -std::string GeneratorProfile::closeArrayString() const +const std::string &GeneratorProfile::closeArrayString() const { return mPimpl->mCloseArrayString; } @@ -3007,7 +3007,7 @@ void GeneratorProfile::setCloseArrayString(const std::string &closeArrayString) mPimpl->mCloseArrayString = closeArrayString; } -std::string GeneratorProfile::arrayElementSeparatorString() const +const std::string &GeneratorProfile::arrayElementSeparatorString() const { return mPimpl->mArrayElementSeparatorString; } @@ -3017,7 +3017,7 @@ void GeneratorProfile::setArrayElementSeparatorString(const std::string &arrayEl mPimpl->mArrayElementSeparatorString = arrayElementSeparatorString; } -std::string GeneratorProfile::commandSeparatorString() const +const std::string &GeneratorProfile::commandSeparatorString() const { return mPimpl->mCommandSeparatorString; } diff --git a/src/generatorvariabletracker.cpp b/src/generatorvariabletracker.cpp index 7ab4f52637..50541b4e01 100644 --- a/src/generatorvariabletracker.cpp +++ b/src/generatorvariabletracker.cpp @@ -299,10 +299,13 @@ void GeneratorVariableTracker::GeneratorVariableTrackerImpl::trackAllAlgebraicVa std::vector GeneratorVariableTracker::GeneratorVariableTrackerImpl::trackableVariables(const AnalyserModelPtr &analyserModel) const { - auto res = analyserModel->constants(); - auto computedConstants = analyserModel->computedConstants(); - auto algebraic = analyserModel->algebraicVariables(); + const auto &constants = analyserModel->constants(); + const auto &computedConstants = analyserModel->computedConstants(); + const auto &algebraic = analyserModel->algebraicVariables(); + std::vector res; + + res.insert(res.end(), constants.begin(), constants.end()); res.insert(res.end(), computedConstants.begin(), computedConstants.end()); res.insert(res.end(), algebraic.begin(), algebraic.end()); diff --git a/src/importedentity.cpp b/src/importedentity.cpp index 4d859929e8..4a93560d23 100644 --- a/src/importedentity.cpp +++ b/src/importedentity.cpp @@ -56,7 +56,7 @@ void ImportedEntity::setImportSource(const ImportSourcePtr &importSource) mPimpl->mImportSource = importSource; } -std::string ImportedEntity::importReference() const +const std::string &ImportedEntity::importReference() const { return mPimpl->mImportReference; } diff --git a/src/importer.cpp b/src/importer.cpp index b0e336b28b..4292169587 100644 --- a/src/importer.cpp +++ b/src/importer.cpp @@ -20,6 +20,7 @@ limitations under the License. #include #include #include +#include #include "libcellml/importsource.h" #include "libcellml/model.h" @@ -116,7 +117,7 @@ Importer::~Importer() std::vector::const_iterator Importer::ImporterImpl::findImportSource(const ImportSourcePtr &importSource) const { return std::find_if(mImports.begin(), mImports.end(), - [=](const ImportSourcePtr &importSrc) -> bool { return importSource->equals(importSrc); }); + [&](const ImportSourcePtr &importSrc) -> bool { return importSource->equals(importSrc); }); } std::string Importer::ImporterImpl::modelUrl(const ModelPtr &model) const @@ -332,12 +333,13 @@ std::string resolvePath(const std::string &filename, const std::string &base) bool Importer::ImporterImpl::fetchModel(const ImportSourcePtr &importSource, const std::string &baseFile) { std::string url = normaliseDirectorySeparator(importSource->url()); - if (mLibrary.count(url) == 0) { + if (mLibrary.find(url) == mLibrary.end()) { url = resolvePath(url, baseFile); } ModelPtr model; - if (mLibrary.count(url) == 0) { + auto libraryIt = mLibrary.find(url); + if (libraryIt == mLibrary.end()) { // If the URL has not ever been resolved into a model in this library, with or // without baseFile, parse it and save. std::ifstream file(url); @@ -378,7 +380,7 @@ bool Importer::ImporterImpl::fetchModel(const ImportSourcePtr &importSource, con } mLibrary.insert(std::make_pair(url, model)); } else { - model = mLibrary[url]; + model = libraryIt->second; } importSource->setModel(model); return true; @@ -815,7 +817,8 @@ ComponentPtr flattenComponent(const ComponentEntityPtr &parent, ComponentPtr &co // Clone import model to not affect origin import model units. auto clonedImportModel = importModel->clone(); - NameList compNames = componentNames(model); + NameList compNamesList = componentNames(model); + std::unordered_set compNames(compNamesList.begin(), compNamesList.end()); // Determine the stack for the destination component. IndexStack destinationComponentBaseIndexStack = indexStackOf(component); @@ -845,7 +848,7 @@ ComponentPtr flattenComponent(const ComponentEntityPtr &parent, ComponentPtr &co StringStringMap aliasedUnitsNames; for (const auto &units : requiredUnits) { const auto iterator = std::find_if(uniqueRequiredUnits.begin(), uniqueRequiredUnits.end(), - [=](const UnitsPtr &u) -> bool { return Units::equivalent(u, units); }); + [&](const UnitsPtr &u) -> bool { return Units::equivalent(u, units); }); if (iterator == uniqueRequiredUnits.end()) { uniqueRequiredUnits.push_back(units); } else if ((*iterator)->name() != units->name()) { @@ -866,7 +869,7 @@ ComponentPtr flattenComponent(const ComponentEntityPtr &parent, ComponentPtr &co std::string originalName = entry.first; size_t count = 0; std::string newName = originalName; - while (std::find(compNames.begin(), compNames.end(), newName) != compNames.end()) { + while (compNames.count(newName) != 0) { newName = originalName + "_" + convertToString(++count); } if (originalName != newName) { @@ -1003,8 +1006,9 @@ size_t Importer::libraryCount() ModelPtr Importer::library(const std::string &key) { auto normalisedKey = normaliseDirectorySeparator(key); - if (pFunc()->mLibrary.count(normalisedKey) != 0) { - return pFunc()->mLibrary[normalisedKey]; + auto it = pFunc()->mLibrary.find(normalisedKey); + if (it != pFunc()->mLibrary.end()) { + return it->second; } return nullptr; } @@ -1026,22 +1030,18 @@ ModelPtr Importer::library(const size_t &index) bool Importer::addModel(const ModelPtr &model, const std::string &key) { auto normalisedKey = normaliseDirectorySeparator(key); - if (pFunc()->mLibrary.count(normalisedKey) != 0) { - // If the key already exists in the library, do nothing. - return false; - } - pFunc()->mLibrary.insert(std::make_pair(normalisedKey, model)); - return true; + return pFunc()->mLibrary.emplace(normalisedKey, model).second; } bool Importer::replaceModel(const ModelPtr &model, const std::string &key) { auto normalisedKey = normaliseDirectorySeparator(key); - if (pFunc()->mLibrary.count(normalisedKey) == 0) { + auto it = pFunc()->mLibrary.find(normalisedKey); + if (it == pFunc()->mLibrary.end()) { // If the key is not found, do nothing. return false; } - pFunc()->mLibrary[normalisedKey] = model; + it->second = model; return true; } @@ -1077,7 +1077,7 @@ bool Importer::addImportSource(const ImportSourcePtr &importSource) // Prevent adding the same import source. if (std::find_if(pFunc()->mImports.begin(), pFunc()->mImports.end(), - [=](const ImportSourcePtr &importSrc) -> bool { return importSource == importSrc; }) + [&](const ImportSourcePtr &importSrc) -> bool { return importSource == importSrc; }) != pFunc()->mImports.end()) { return false; } diff --git a/src/importsource.cpp b/src/importsource.cpp index 4d929fd006..eec70a6898 100644 --- a/src/importsource.cpp +++ b/src/importsource.cpp @@ -62,7 +62,7 @@ ImportSourcePtr ImportSource::create() noexcept return std::shared_ptr {new ImportSource {}}; } -std::string ImportSource::url() const +const std::string &ImportSource::url() const { return pFunc()->mUrl; } diff --git a/src/internaltypes.h b/src/internaltypes.h index 77d278877b..018c14464d 100644 --- a/src/internaltypes.h +++ b/src/internaltypes.h @@ -18,6 +18,7 @@ limitations under the License. #include #include +#include #include #include @@ -29,7 +30,7 @@ namespace libcellml { const std::string ORIGIN_MODEL_REF = ":this:"; -using ComponentNameMap = std::map; /**< Type definition for map of component name to component pointer. */ +using ComponentNameMap = std::unordered_map; /**< Type definition for map of component name to component pointer. */ using IndexStack = std::vector; /**< Type definition for tracking indices. */ using EquivalenceMap = std::map>; /**< Type definition for map of variable equivalences defined over model. */ @@ -37,7 +38,7 @@ using EquivalenceMap = std::map>; /**< Type using NamePair = std::pair; /**< Type definition for pair of names. */ using NameList = std::vector; /**< Type definition for list of names. */ using DescriptionList = std::vector>; /**< Type definition for list of variables and associated description. */ -using StringStringMap = std::map; /**< Type definition for map of string to string. */ +using StringStringMap = std::unordered_map; /**< Type definition for map of string to string. */ using UniqueNames = std::set; /**< Type definition for a set of unique names. */ using NodeAttributeNamespaceInfo = std::vector>; /**< Type definition for attribute namespace information. */ @@ -56,7 +57,7 @@ using IdMap = std::map>>; / using ImportLibrary = std::map; /** Type definition for library map of imported models. */ using IdList = std::unordered_set; /**< Type definition for list of identifiers. */ -using ResetOrderMap = std::map>; /** Type definition for map of variable to reset order. **/ +using ResetOrderMap = std::unordered_map>; /** Type definition for map of variable to reset order. **/ using AnalyserEquationAstWeakPtr = std::weak_ptr; /**< Type definition for weak analyser equation AST pointer. */ using AnalyserEquationWeakPtr = std::weak_ptr; /**< Type definition for weak analyser equation pointer. */ @@ -76,7 +77,7 @@ using ModelConstPtr = std::shared_ptr; /**< Type definition for sha using ParentedEntityConstPtr = std::shared_ptr; /**< Type definition for shared parented entity const pointer. */ using UnitsConstPtr = std::shared_ptr; /**< Type definition for shared units const pointer. */ -using ConnectionMap = std::map; /**< Type definition for a connection map.*/ +using ConnectionMap = std::unordered_map; /**< Type definition for a connection map.*/ using NamePairList = std::vector; /**< Type definition for a list of a pair of names. */ using ComponentRawPtrPair = std::pair; /**< Type definition for pair of raw component pointers. */ diff --git a/src/issue.cpp b/src/issue.cpp index da64bd978e..f0d8eb7768 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -51,7 +51,7 @@ Issue::~Issue() delete mPimpl; } -std::string Issue::description() const +const std::string &Issue::description() const { return mPimpl->mDescription; } diff --git a/src/model.cpp b/src/model.cpp index 56e18d6ad9..36bf6b196b 100644 --- a/src/model.cpp +++ b/src/model.cpp @@ -18,6 +18,7 @@ limitations under the License. #include #include +#include #include #include "libcellml/component.h" @@ -37,7 +38,7 @@ namespace libcellml { std::vector::const_iterator Model::ModelImpl::findUnits(const std::string &name) const { return std::find_if(mUnits.begin(), mUnits.end(), - [=](const UnitsPtr &u) -> bool { return u->name() == name; }); + [&](const UnitsPtr &u) -> bool { return u->name() == name; }); } std::vector::const_iterator Model::ModelImpl::findUnits(const UnitsPtr &units) const @@ -47,7 +48,7 @@ std::vector::const_iterator Model::ModelImpl::findUnits(const UnitsPtr return result; } return std::find_if(mUnits.begin(), mUnits.end(), - [=](const UnitsPtr &u) -> bool { return u->equals(units); }); + [&](const UnitsPtr &u) -> bool { return u->equals(units); }); } bool Model::ModelImpl::equalUnits(const ModelPtr &other) const @@ -461,19 +462,20 @@ bool Model::doEquals(const EntityPtr &other) const std::vector Model::importRequirements() const { std::vector requirements; + std::unordered_set seenUrls; auto importedComponents = getImportedComponents(shared_from_this()); auto importedUnits = getImportedUnits(shared_from_this()); for (auto &component : importedComponents) { auto url = component->importSource()->url(); - if (std::find(requirements.begin(), requirements.end(), url) == requirements.end()) { + if (seenUrls.insert(url).second) { requirements.push_back(url); } } for (auto &units : importedUnits) { auto url = units->importSource()->url(); - if (std::find(requirements.begin(), requirements.end(), url) == requirements.end()) { + if (seenUrls.insert(url).second) { requirements.push_back(url); } } diff --git a/src/namedentity.cpp b/src/namedentity.cpp index 835448808a..6a245a07a1 100644 --- a/src/namedentity.cpp +++ b/src/namedentity.cpp @@ -40,7 +40,7 @@ void NamedEntity::setName(const std::string &name) pFunc()->mName = name; } -std::string NamedEntity::name() const +const std::string &NamedEntity::name() const { return pFunc()->mName; } diff --git a/src/parser.cpp b/src/parser.cpp index 7728f4ccd6..8d4f76d64a 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -407,8 +407,8 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp auto elementNamespaceMap = traverseTreeForElementNamespaces(node); if (mParsing20Version) { for (const auto &e : elementNamespaceMap) { - std::string name = e.first; - std::string uri = e.second; + const auto &name = e.first; + const auto &uri = e.second; if ((uri != CELLML_2_0_NS) && (uri != MATHML_NS)) { auto issue = Issue::IssueImpl::create(); issue->mPimpl->setDescription("Element '" + name + "' uses namespace '" + uri + "' which does not belong to an allowed namespace. "); @@ -421,10 +421,10 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp auto attributeNamespaceMap = traverseTreeForAttributeNamespaces(node); if (mParsing20Version) { for (const auto &e : attributeNamespaceMap) { - std::string nodeName = std::get<0>(e); - std::string nodeUri = std::get<4>(e); - std::string attributeName = std::get<1>(e); - std::string uri = std::get<3>(e); + const auto &nodeName = std::get<0>(e); + const auto &nodeUri = std::get<4>(e); + const auto &attributeName = std::get<1>(e); + const auto &uri = std::get<3>(e); if ((nodeName == "cn") && (nodeUri == MATHML_NS) && (attributeName == "units") && (uri == CELLML_2_0_NS)) { // Explicitly allowed attribute namespace prefix. } else if ((nodeName == "import") && (nodeUri == CELLML_2_0_NS) && (attributeName == "href") && (uri == XLINK_NS)) { diff --git a/src/printer.cpp b/src/printer.cpp index 6a39d3a5f5..c3cdaf3b12 100644 --- a/src/printer.cpp +++ b/src/printer.cpp @@ -16,7 +16,9 @@ limitations under the License. #include "libcellml/printer.h" -#include +#include +#include +#include #include #include @@ -57,8 +59,11 @@ class Printer::PrinterImpl: public Logger::LoggerImpl std::string printMapVariables(const VariablePairPtr &variablePair, IdList &idList, bool autoIds) { - std::string mapVariables = "variable1()->name() + "\"" - + " variable_2=\"" + variablePair->variable2()->name() + "\""; + const auto &variable1Name = variablePair->variable1()->name(); + const auto &variable2Name = variablePair->variable2()->name(); + std::string mapVariables; + mapVariables = "variable1(), variablePair->variable2()); if (!mappingId.empty()) { mapVariables += " id=\"" + mappingId + "\""; @@ -72,22 +77,15 @@ std::string printMapVariables(const VariablePairPtr &variablePair, IdList &idLis std::string printConnections(const ComponentMap &componentMap, const VariableMap &variableMap, IdList &idList, bool autoIds) { std::string connections; - ComponentMap serialisedComponentMap; + using ComponentPairKey = std::pair; + std::set serialisedComponentPairs; size_t componentMapIndex1 = 0; for (auto iterPair = componentMap.begin(); iterPair < componentMap.end(); ++iterPair) { ComponentPtr currentComponent1 = iterPair->first; ComponentPtr currentComponent2 = iterPair->second; - ComponentPair currentComponentPair = std::make_pair(currentComponent1, currentComponent2); - // Check whether this set of connections has already been serialised. - bool pairFound = false; - for (const auto &serialisedIterPair : serialisedComponentMap) { - if (serialisedIterPair == currentComponentPair) { - pairFound = true; - break; - } - } + ComponentPairKey currentKey = std::make_pair(currentComponent1.get(), currentComponent2.get()); // Continue to the next component pair if the current pair has already been serialised. - if (pairFound) { + if (!serialisedComponentPairs.insert(currentKey).second) { ++componentMapIndex1; continue; } @@ -118,7 +116,6 @@ std::string printConnections(const ComponentMap &componentMap, const VariableMap connections += " id=\"" + makeUniqueId(idList) + "\""; } connections += ">" + mappingVariables + ""; - serialisedComponentMap.push_back(currentComponentPair); ++componentMapIndex1; } @@ -128,14 +125,23 @@ std::string printConnections(const ComponentMap &componentMap, const VariableMap std::string Printer::PrinterImpl::printMath(const std::string &math) { static const std::string wrapElementName = "math_wrap_as_single_root_element"; - static const std::regex before(">[\\s\n\t]*"); - static const std::regex after("[\\s\n\t]*<"); - static const std::regex xmlDeclaration(R"|(<\?xml[[:space:]]+version=.*\?>)|"); XmlDocPtr xmlDoc = std::make_shared(); xmlKeepBlanksDefault(0); - // Remove any XML declarations from the string. - std::string normalisedMath = std::regex_replace(math, xmlDeclaration, ""); + // Remove a leading XML declaration from the string, but preserve other processing instructions such as + // . + std::string normalisedMath = math; + size_t pos = 0; + while ((pos = normalisedMath.find("(normalisedMath[pos + 5]))) { + auto end = normalisedMath.find("?>", pos + 5); + if (end != std::string::npos) { + normalisedMath.erase(pos, end + 2 - pos); + continue; + } + } + pos += 5; + } xmlDoc->parse("<" + wrapElementName + ">" + normalisedMath + ""); if (xmlDoc->xmlErrorCount() == 0) { auto rootNode = xmlDoc->rootNode(); @@ -146,8 +152,27 @@ std::string Printer::PrinterImpl::printMath(const std::string &math) childNode = childNode->next(); } // Clean whitespace in the math. - result = std::regex_replace(result, before, ">"); - return std::regex_replace(result, after, "<"); + std::string cleaned; + bool afterGt = false; + for (char c : result) { + if (c == '>') { + cleaned += c; + afterGt = true; + } else if (afterGt && std::isspace(static_cast(c))) { + // Skip whitespace after >. + } else if (c == '<') { + afterGt = false; + // Trim whitespace before <. + while (!cleaned.empty() && std::isspace(static_cast(cleaned.back()))) { + cleaned.pop_back(); + } + cleaned += c; + } else { + afterGt = false; + cleaned += c; + } + } + return cleaned; } else { for (size_t i = 0; i < xmlDoc->xmlErrorCount(); ++i) { auto issue = Issue::IssueImpl::create(); @@ -160,37 +185,37 @@ std::string Printer::PrinterImpl::printMath(const std::string &math) return ""; } -void buildMapsForComponentsVariables(const ComponentPtr &component, ComponentMap &componentMap, VariableMap &variableMap) +using SeenPairsSet = std::set>; + +void buildMapsForComponentsVariables(const ComponentPtr &component, ComponentMap &componentMap, VariableMap &variableMap, SeenPairsSet &seenPairs) { for (size_t i = 0; i < component->variableCount(); ++i) { VariablePtr variable = component->variable(i); for (size_t j = 0; j < variable->equivalentVariableCount(); ++j) { VariablePtr equivalentVariable = variable->equivalentVariable(j); - VariablePairPtr variablePair = VariablePair::create(variable, equivalentVariable); - auto pairFound = std::find_if(variableMap.begin(), variableMap.end(), - [variable, equivalentVariable](const VariablePairPtr &in) { - return (in->variable1() == equivalentVariable) && (in->variable2() == variable); - }); - if (pairFound == variableMap.end()) { + // Check for the reverse pair (equivalentVariable, variable) to avoid duplicates. + auto reverseKey = std::make_pair(equivalentVariable.get(), variable.get()); + if (seenPairs.find(reverseKey) == seenPairs.end()) { // Add new unique variable equivalence pair to the VariableMap. - variableMap.push_back(variablePair); + variableMap.push_back(VariablePair::create(variable, equivalentVariable)); + // Record the forward pair as seen. + seenPairs.insert(std::make_pair(variable.get(), equivalentVariable.get())); // Get parent components. ComponentPtr component1 = owningComponent(variable); ComponentPtr component2 = owningComponent(equivalentVariable); // Also create a component map pair corresponding with the variable map pair. - ComponentPair componentPair = std::make_pair(component1, component2); - componentMap.push_back(componentPair); + componentMap.emplace_back(std::move(component1), std::move(component2)); } } } } -void buildMaps(const ComponentEntityPtr &componentEntity, ComponentMap &componentMap, VariableMap &variableMap) +void buildMaps(const ComponentEntityPtr &componentEntity, ComponentMap &componentMap, VariableMap &variableMap, SeenPairsSet &seenPairs) { for (size_t i = 0; i < componentEntity->componentCount(); ++i) { ComponentPtr component = componentEntity->component(i); - buildMapsForComponentsVariables(component, componentMap, variableMap); - buildMaps(component, componentMap, variableMap); + buildMapsForComponentsVariables(component, componentMap, variableMap, seenPairs); + buildMaps(component, componentMap, variableMap, seenPairs); } } @@ -198,21 +223,23 @@ std::string Printer::PrinterImpl::printUnits(const UnitsPtr &units, IdList &idLi { std::string repr; if (!units->isImport() && !isStandardUnit(units)) { + const auto unitCount = units->unitCount(); bool endTag = false; repr += "name(); if (!unitsName.empty()) { repr += " name=\"" + unitsName + "\""; } - if (!units->id().empty()) { - repr += " id=\"" + units->id() + "\""; + auto unitsId = units->id(); + if (!unitsId.empty()) { + repr += " id=\"" + unitsId + "\""; } else if (autoIds) { repr += " id=\"" + makeUniqueId(idList) + "\""; } - if (units->unitCount() > 0) { + if (unitCount > 0) { endTag = true; repr += ">"; - for (size_t i = 0; i < units->unitCount(); ++i) { + for (size_t i = 0; i < unitCount; ++i) { std::string reference; std::string prefix; std::string id; @@ -257,8 +284,9 @@ std::string Printer::PrinterImpl::printComponent(const ComponentPtr &component, if (!componentName.empty()) { repr += " name=\"" + componentName + "\""; } - if (!component->id().empty()) { - repr += " id=\"" + component->id() + "\""; + auto componentId = component->id(); + if (!componentId.empty()) { + repr += " id=\"" + componentId + "\""; } else if (autoIds) { repr += " id=\"" + makeUniqueId(idList) + "\""; } @@ -436,17 +464,16 @@ std::string Printer::PrinterImpl::printImports(const ModelPtr &model, IdList &id std::string repr; std::vector collatedImportSources; + std::unordered_set seenImportSources; auto importedComponents = getImportedComponents(model); for (auto &component : importedComponents) { - auto result = std::find(collatedImportSources.begin(), collatedImportSources.end(), component->importSource()); - if (result == collatedImportSources.end()) { + if (seenImportSources.insert(component->importSource().get()).second) { collatedImportSources.push_back(component->importSource()); } } auto importedUnits = getImportedUnits(model); for (auto &units : importedUnits) { - auto result = std::find(collatedImportSources.begin(), collatedImportSources.end(), units->importSource()); - if (result == collatedImportSources.end()) { + if (seenImportSources.insert(units->importSource().get()).second) { collatedImportSources.push_back(units->importSource()); } } @@ -462,8 +489,9 @@ std::string Printer::PrinterImpl::printImports(const ModelPtr &model, IdList &id for (const UnitsPtr &units : importedUnits) { if (units->importSource() == importSource) { repr += "importReference() + "\" name=\"" + units->name() + "\""; - if (!units->id().empty()) { - repr += " id=\"" + units->id() + "\""; + auto unitsId = units->id(); + if (!unitsId.empty()) { + repr += " id=\"" + unitsId + "\""; } else if (autoIds) { repr += " id=\"" + makeUniqueId(idList) + "\""; } @@ -473,8 +501,9 @@ std::string Printer::PrinterImpl::printImports(const ModelPtr &model, IdList &id for (const ComponentPtr &component : importedComponents) { if (component->importSource() == importSource) { repr += "importReference() + "\" name=\"" + component->name() + "\""; - if (!component->id().empty()) { - repr += " id=\"" + component->id() + "\""; + auto componentId = component->id(); + if (!componentId.empty()) { + repr += " id=\"" + componentId + "\""; } else if (autoIds) { repr += " id=\"" + makeUniqueId(idList) + "\""; } @@ -521,11 +550,13 @@ std::string Printer::printModel(const ModelPtr &model, bool autoIds) std::string repr; repr += "name().empty()) { - repr += " name=\"" + model->name() + "\""; + auto modelName = model->name(); + if (!modelName.empty()) { + repr += " name=\"" + modelName + "\""; } - if (!model->id().empty()) { - repr += " id=\"" + model->id() + "\""; + auto modelId = model->id(); + if (!modelId.empty()) { + repr += " id=\"" + modelId + "\""; } else if (autoIds) { repr += " id=\"" + makeUniqueId(idList) + "\""; } @@ -557,8 +588,9 @@ std::string Printer::printModel(const ModelPtr &model, bool autoIds) VariableMap variableMap; ComponentMap componentMap; + SeenPairsSet seenPairs; // Build unique variable equivalence pairs (ComponentMap, VariableMap) for connections. - buildMaps(model, componentMap, variableMap); + buildMaps(model, componentMap, variableMap, seenPairs); // Serialise connections of the model. repr += printConnections(componentMap, variableMap, idList, autoIds); diff --git a/src/reset.cpp b/src/reset.cpp index d334688d9b..94c6283b53 100644 --- a/src/reset.cpp +++ b/src/reset.cpp @@ -104,7 +104,7 @@ void Reset::appendTestValue(const std::string &math) pFunc()->mTestValue.append(math); } -std::string Reset::testValue() const +const std::string &Reset::testValue() const { return pFunc()->mTestValue; } @@ -119,7 +119,7 @@ void Reset::removeTestValueId() pFunc()->mTestValueId = ""; } -std::string Reset::testValueId() const +const std::string &Reset::testValueId() const { return pFunc()->mTestValueId; } @@ -139,7 +139,7 @@ void Reset::appendResetValue(const std::string &math) pFunc()->mResetValue.append(math); } -std::string Reset::resetValue() const +const std::string &Reset::resetValue() const { return pFunc()->mResetValue; } @@ -164,7 +164,7 @@ void Reset::removeResetValueId() pFunc()->mResetValueId = ""; } -std::string Reset::resetValueId() const +const std::string &Reset::resetValueId() const { return pFunc()->mResetValueId; } diff --git a/src/units.cpp b/src/units.cpp index 2cddc08111..c684bfe85c 100644 --- a/src/units.cpp +++ b/src/units.cpp @@ -93,7 +93,7 @@ static const std::map standardUnitToStri std::vector::const_iterator Units::UnitsImpl::findUnit(const std::string &reference) const { return std::find_if(mUnitDefinitions.begin(), mUnitDefinitions.end(), - [=](const UnitDefinition &u) -> bool { return u.mReference == reference; }); + [&](const UnitDefinition &u) -> bool { return u.mReference == reference; }); } Units::UnitsImpl *Units::pFunc() @@ -433,15 +433,20 @@ void Units::unitAttributes(const std::string &reference, std::string &prefix, do void Units::unitAttributes(size_t index, std::string &reference, std::string &prefix, double &exponent, double &multiplier, std::string &id) const { - UnitDefinition ud; if (index < pFunc()->mUnitDefinitions.size()) { - ud = pFunc()->mUnitDefinitions.at(index); + const auto &ud = pFunc()->mUnitDefinitions[index]; + reference = ud.mReference; + prefix = ud.mPrefix; + exponent = ud.mExponent; + multiplier = ud.mMultiplier; + id = ud.mId; + } else { + reference.clear(); + prefix.clear(); + exponent = 1.0; + multiplier = 1.0; + id.clear(); } - reference = ud.mReference; - prefix = ud.mPrefix; - exponent = ud.mExponent; - multiplier = ud.mMultiplier; - id = ud.mId; } std::string Units::unitAttributeReference(size_t index) const @@ -458,9 +463,7 @@ std::string Units::unitAttributeReference(size_t index) const void Units::setUnitAttributeReference(size_t index, const std::string &reference) { if (index < pFunc()->mUnitDefinitions.size()) { - UnitDefinition unitDefinition = pFunc()->mUnitDefinitions.at(index); - unitDefinition.mReference = reference; - pFunc()->mUnitDefinitions[index] = unitDefinition; + pFunc()->mUnitDefinitions[index].mReference = reference; } } diff --git a/src/utilities.cpp b/src/utilities.cpp index b589391739..1957b36e69 100644 --- a/src/utilities.cpp +++ b/src/utilities.cpp @@ -19,11 +19,13 @@ limitations under the License. #include #include #include +#include #include #include #include -#include +#include #include +#include #include #include "libcellml/analyserequation.h" @@ -102,6 +104,7 @@ bool hasNonWhitespaceCharacters(const std::string &input) Strings split(const std::string &content, const std::string &delimiter) { Strings strings; + size_t current; size_t previous = 0; current = content.find(delimiter); @@ -124,6 +127,10 @@ std::string convertToString(double value, bool fullPrecision) } std::ostringstream strs; if (fullPrecision) { + auto roundedValue = static_cast(std::llround(value)); + if (areNearlyEqual(value, roundedValue)) { + value = roundedValue; + } strs << std::setprecision(std::numeric_limits::digits10) << value; } else { strs << value; @@ -166,22 +173,17 @@ int convertPrefixToInt(const std::string &in, bool *ok) std::string convertToString(size_t value) { - std::ostringstream strs; - strs << value; - return strs.str(); + return std::format("{}", value); } std::string convertToString(int value) { - std::ostringstream strs; - strs << value; - return strs.str(); + return std::format("{}", value); } bool isEuropeanNumericCharacter(char c) { - const std::set validIntegerCharacters = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}; - return validIntegerCharacters.find(c) != validIntegerCharacters.end(); + return (c >= '0') && (c <= '9'); } bool isNonNegativeCellMLInteger(const std::string &candidate) @@ -302,7 +304,7 @@ uint64_t ulpsDistance(double a, double b) bool areNearlyEqual(double a, double b) { - static const double fixedEpsilon = std::numeric_limits::epsilon(); + static const double fixedEpsilon = epsilon(); static const ptrdiff_t ulpsEpsilon = 1; if (fabs(a - b) <= fixedEpsilon) { @@ -327,7 +329,6 @@ std::vector getImportedComponents(const ComponentEntityConstPtr &c } auto childImportedComponents = getImportedComponents(component); - importedComponents.reserve(importedComponents.size() + childImportedComponents.size()); importedComponents.insert(importedComponents.end(), childImportedComponents.begin(), childImportedComponents.end()); } @@ -354,7 +355,6 @@ std::vector getAllImportSources(const ModelConstPtr &model) auto importedComponents = getImportedComponents(model); auto importedUnits = getImportedUnits(model); - importSources.reserve(importedComponents.size() + importedUnits.size()); for (auto &component : importedComponents) { importSources.push_back(component->importSource()); } @@ -667,15 +667,15 @@ EquivalenceMap rebaseEquivalenceMap(const EquivalenceMap &map, const IndexStack { EquivalenceMap rebasedMap; for (const auto &entry : map) { - auto key = entry.first; + const auto &key = entry.first; auto rebasedKey = rebaseIndexStack(key, originStack, destinationStack); - auto vector = entry.second; + const auto &vector = entry.second; std::vector rebasedVector; - for (auto stack : vector) { + for (const auto &stack : vector) { // Temporarily remove the variable index whilst we rebase the component part of the stack. size_t variableIndex = stack.back(); - stack.pop_back(); - auto rebasedTarget = rebaseIndexStack(stack, originStack, destinationStack); + IndexStack componentStack(stack.begin(), stack.end() - 1); + auto rebasedTarget = rebaseIndexStack(componentStack, originStack, destinationStack); if (!rebasedTarget.empty()) { rebasedTarget.push_back(variableIndex); rebasedVector.push_back(rebasedTarget); @@ -827,9 +827,6 @@ void recordVariableEquivalences(const ComponentPtr &component, EquivalenceMap &e } auto equivalentVariable = variable->equivalentVariable(j); auto equivalentVariableIndexStack = indexStackOf(equivalentVariable); - if (equivalenceMap.count(indexStack) == 0) { - equivalenceMap.emplace(indexStack, std::vector()); - } equivalenceMap[indexStack].push_back(equivalentVariableIndexStack); } if (variable->equivalentVariableCount() > 0) { @@ -1035,24 +1032,25 @@ ConnectionMap createConnectionMap(const VariablePtr &variable1, const VariablePt return map; } -void recursiveEquivalentVariables(const VariablePtr &variable, std::vector &equivalentVariables) +void recursiveEquivalentVariables(const VariablePtr &variable, VariablePtrs &equivalentVariables, std::unordered_set &seenVariables) { for (size_t i = 0; i < variable->equivalentVariableCount(); ++i) { - VariablePtr equivalentVariable = variable->equivalentVariable(i); + auto equivalentVariable = variable->equivalentVariable(i); - if (std::find(equivalentVariables.begin(), equivalentVariables.end(), equivalentVariable) == equivalentVariables.end()) { + if (seenVariables.insert(equivalentVariable.get()).second) { equivalentVariables.push_back(equivalentVariable); - recursiveEquivalentVariables(equivalentVariable, equivalentVariables); + recursiveEquivalentVariables(equivalentVariable, equivalentVariables, seenVariables); } } } -std::vector equivalentVariables(const VariablePtr &variable) +VariablePtrs equivalentVariables(const VariablePtr &variable) { - std::vector res = {variable}; + VariablePtrs res = {variable}; + std::unordered_set seenVariables = {variable.get()}; - recursiveEquivalentVariables(variable, res); + recursiveEquivalentVariables(variable, res, seenVariables); return res; } @@ -1075,11 +1073,11 @@ bool linkComponentVariableUnits(const ComponentPtr &component, DescriptionList & if (model->hasUnits(u->name())) { v->setUnits(model->units(u->name())); } else { - descriptionList.push_back(std::make_pair(v, "Model does not contain the units '" + u->name() + "' required by variable '" + v->name() + "' in component '" + component->name() + "'.")); + descriptionList.emplace_back(v, "Model does not contain the units '" + u->name() + "' required by variable '" + v->name() + "' in component '" + component->name() + "'."); status = false; } } else if (model != nullptr) { - descriptionList.push_back(std::make_pair(v, "The units '" + u->name() + "' assigned to variable '" + v->name() + "' in component '" + component->name() + "' belong to a different model, '" + model->name() + "'.")); + descriptionList.emplace_back(v, "The units '" + u->name() + "' assigned to variable '" + v->name() + "' in component '" + component->name() + "' belong to a different model, '" + model->name() + "'."); status = false; } } @@ -1317,9 +1315,9 @@ XmlNodePtr mathmlChildNode(const XmlNodePtr &node, size_t index) return res; } -std::vector analyserVariables(const AnalyserVariablePtr &analyserVariable) +const std::vector &analyserVariables(const AnalyserVariablePtr &analyserVariable) { - std::vector res; + static const std::vector NO_ANALYSER_VARIABLE; switch (analyserVariable->type()) { case AnalyserVariable::Type::CONSTANT: @@ -1333,26 +1331,23 @@ std::vector analyserVariables(const AnalyserVariablePtr &an break; } - return {}; + return NO_ANALYSER_VARIABLE; } std::vector analyserVariables(const AnalyserModelPtr &analyserModel) { std::vector res; + const auto &states = analyserModel->states(); + const auto &constants = analyserModel->constants(); + const auto &computedConstants = analyserModel->computedConstants(); + const auto &algebraicVariables = analyserModel->algebraicVariables(); + const auto &externalVariables = analyserModel->externalVariables(); if (analyserModel->voi() != nullptr) { res.push_back(analyserModel->voi()); } - auto states = analyserModel->states(); - res.insert(res.end(), states.begin(), states.end()); - - auto constants = analyserModel->constants(); - auto computedConstants = analyserModel->computedConstants(); - auto algebraicVariables = analyserModel->algebraicVariables(); - auto externalVariables = analyserModel->externalVariables(); - res.insert(res.end(), constants.begin(), constants.end()); res.insert(res.end(), computedConstants.begin(), computedConstants.end()); res.insert(res.end(), algebraicVariables.begin(), algebraicVariables.end()); @@ -1363,11 +1358,13 @@ std::vector analyserVariables(const AnalyserModelPtr &analy std::vector analyserVariables(const AnalyserEquationPtr &analyserEquation) { - auto res = analyserEquation->states(); - auto computedConstants = analyserEquation->computedConstants(); - auto algebraicVariables = analyserEquation->algebraicVariables(); - auto externalVariables = analyserEquation->externalVariables(); + std::vector res; + const auto &states = analyserEquation->states(); + const auto &computedConstants = analyserEquation->computedConstants(); + const auto &algebraicVariables = analyserEquation->algebraicVariables(); + const auto &externalVariables = analyserEquation->externalVariables(); + res.insert(res.end(), states.begin(), states.end()); res.insert(res.end(), computedConstants.begin(), computedConstants.end()); res.insert(res.end(), algebraicVariables.begin(), algebraicVariables.end()); res.insert(res.end(), externalVariables.begin(), externalVariables.end()); diff --git a/src/utilities.h b/src/utilities.h index 888447f1f2..4eb0c82e6e 100644 --- a/src/utilities.h +++ b/src/utilities.h @@ -879,7 +879,7 @@ XmlNodePtr mathmlChildNode(const XmlNodePtr &node, size_t index); * * @return The analyser variables of the same type as the given analyser variable. */ -std::vector analyserVariables(const AnalyserVariablePtr &analyserVariable); +const std::vector &analyserVariables(const AnalyserVariablePtr &analyserVariable); /** * @brief Return the analyser variables in the given analyser model. diff --git a/src/validator.cpp b/src/validator.cpp index f0d17bb972..68e8cd5b31 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -18,12 +18,13 @@ limitations under the License. #include #include +#include #include #include -#include -#include #include #include +#include +#include #include "libcellml/importsource.h" #include "libcellml/reset.h" @@ -308,7 +309,7 @@ class Validator::ValidatorImpl: public LoggerImpl * @param component The component to validate the name of. * @param names The list of component names already used in the model. */ - void validateUniqueName(const ModelPtr &model, const ComponentPtr &component, NameList &names); + void validateUniqueName(const ModelPtr &model, const ComponentPtr &component, std::unordered_set &namesSet); /** * @brief Validate the @p component using the CellML 2.0 Specification. @@ -334,7 +335,7 @@ class Validator::ValidatorImpl: public LoggerImpl * @param history The history of visited components. * @param modelsVisited The list of visited models. */ - void validateComponentTree(const ModelPtr &model, const ComponentPtr &component, NameList &componentNames, History &history, std::vector &modelsVisited); + void validateComponentTree(const ModelPtr &model, const ComponentPtr &component, std::unordered_set &componentNames, History &history, std::vector &modelsVisited); /** * @brief Validate the @p units using the CellML 2.0 Specification. @@ -412,7 +413,7 @@ class Validator::ValidatorImpl: public LoggerImpl * @param variable The variable to validate. * @param variableNames A vector list of the name attributes of the @p variable and its siblings. */ - void validateVariable(const VariablePtr &variable, const NameList &variableNames); + void validateVariable(const VariablePtr &variable, const std::unordered_set &variableNames); /** * @brief Validate the @p reset using the CellML 2.0 Specification. @@ -477,7 +478,7 @@ class Validator::ValidatorImpl: public LoggerImpl * @param component The component the @p node is a part of. * @param variableNames A list of variable names. */ - void validateAndCleanCiNode(const XmlNodePtr &node, const ComponentPtr &component, const NameList &variableNames); + void validateAndCleanCiNode(const XmlNodePtr &node, const ComponentPtr &component, const std::unordered_set &variableNames); /** * @brief Validate the text of a @c cn element. @@ -503,7 +504,7 @@ class Validator::ValidatorImpl: public LoggerImpl * @param component The component that the math @c XmlNode @p node is contained within. * @param variableNames A @c vector list of the names of variables found within the @p component. */ - void validateAndCleanMathCiCnNodes(XmlNodePtr &node, const ComponentPtr &component, const NameList &variableNames); + void validateAndCleanMathCiCnNodes(XmlNodePtr &node, const ComponentPtr &component, const std::unordered_set &variableNames); /** * @brief Add a MathML-related issue. @@ -641,7 +642,7 @@ class Validator::ValidatorImpl: public LoggerImpl * @param reportedConnections A set of connection identifiers to prevent duplicate reporting. * @param connectionIds A map to speed up lookups for component to component connection identifiers. */ - void buildComponentIdMap(const ComponentPtr &component, IdMap &idMap, std::set &reportedConnections, const ConnectionIdMap &connectionIds); + void buildComponentIdMap(const ComponentPtr &component, IdMap &idMap, std::unordered_set &reportedConnections, const ConnectionIdMap &connectionIds); /** @brief Utility function to add an item to the idMap. * @@ -729,7 +730,7 @@ class Validator::ValidatorImpl: public LoggerImpl bool checkForLocalCycles(const History &history, const HistoryEpochPtr &h) { return std::find_if(history.begin(), history.end(), - [=](const HistoryEpochPtr &i) -> bool { return (i->mName == h->mName) && (i->mSourceUrl == h->mSourceUrl); }) + [&](const HistoryEpochPtr &i) -> bool { return (i->mName == h->mName) && (i->mSourceUrl == h->mSourceUrl); }) != history.end(); } @@ -766,25 +767,27 @@ void Validator::validateModel(const ModelPtr &model) pFunc()->addIssue(issue); } else { // Check for a valid name attribute. - if (!isCellmlIdentifier(model->name())) { - auto issue = pFunc()->makeIssueIllegalIdentifier(model->name()); + const auto &modelName = model->name(); + if (!isCellmlIdentifier(modelName)) { + auto issue = pFunc()->makeIssueIllegalIdentifier(modelName); issue->mPimpl->mItem->mPimpl->setModel(model); issue->mPimpl->setReferenceRule(Issue::ReferenceRule::MODEL_NAME_VALUE); - issue->mPimpl->setDescription("Model '" + model->name() + "' does not have a valid name attribute. " + issue->description()); + issue->mPimpl->setDescription("Model '" + modelName + "' does not have a valid name attribute. " + issue->description()); pFunc()->addIssue(issue); } // Check for a valid identifier. - if (!isValidXmlName(model->id())) { + const auto &modelId = model->id(); + if (!isValidXmlName(modelId)) { auto issue = Issue::IssueImpl::create(); issue->mPimpl->setReferenceRule(Issue::ReferenceRule::XML_ID_ATTRIBUTE); issue->mPimpl->mItem->mPimpl->setModel(model); - issue->mPimpl->setDescription("Model '" + model->name() + "' does not have a valid 'id' attribute, '" + model->id() + "'."); + issue->mPimpl->setDescription("Model '" + modelName + "' does not have a valid 'id' attribute, '" + modelId + "'."); pFunc()->addIssue(issue); } std::vector modelsVisited = {model}; // Check for components in this model. if (model->componentCount() > 0) { - NameList componentNames; + std::unordered_set componentNames; History history; for (size_t i = 0; i < model->componentCount(); ++i) { history.clear(); @@ -812,11 +815,11 @@ void Validator::validateModel(const ModelPtr &model) } } -void Validator::ValidatorImpl::validateUniqueName(const ModelPtr &model, const ComponentPtr &component, NameList &names) +void Validator::ValidatorImpl::validateUniqueName(const ModelPtr &model, const ComponentPtr &component, std::unordered_set &namesSet) { std::string name = component->name(); if (!name.empty()) { - if (std::find(names.begin(), names.end(), name) != names.end()) { + if (!namesSet.insert(name).second) { auto issue = Issue::IssueImpl::create(); issue->mPimpl->setDescription("Model '" + model->name() + "' contains multiple components with the name '" + name + "'. Valid component names must be unique to their model."); issue->mPimpl->mItem->mPimpl->setModel(model); @@ -826,13 +829,11 @@ void Validator::ValidatorImpl::validateUniqueName(const ModelPtr &model, const C issue->mPimpl->setReferenceRule(Issue::ReferenceRule::COMPONENT_NAME_UNIQUE); } addIssue(issue); - } else { - names.push_back(name); } } } -void Validator::ValidatorImpl::validateComponentTree(const ModelPtr &model, const ComponentPtr &component, NameList &componentNames, History &history, std::vector &modelsVisited) +void Validator::ValidatorImpl::validateComponentTree(const ModelPtr &model, const ComponentPtr &component, std::unordered_set &componentNames, History &history, std::vector &modelsVisited) { validateUniqueName(model, component, componentNames); for (size_t i = 0; i < component->componentCount(); ++i) { @@ -1019,12 +1020,12 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component, } } else { // Check for variables in this component. - NameList variableNames; + std::unordered_set variableNames; // Validate variable(s). for (size_t i = 0; i < component->variableCount(); ++i) { VariablePtr variable = component->variable(i); validateVariable(variable, variableNames); - variableNames.push_back(variable->name()); + variableNames.insert(variable->name()); } // Check for resets in this component. for (size_t i = 0; i < component->resetCount(); ++i) { @@ -1041,12 +1042,12 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component, handleErrorsFromImports(initialIssueCount, isOriginatingModel, "Component", componentName, history, component, nullptr); } -std::set namesInCycle(NameList allNames) +std::unordered_set namesInCycle(NameList allNames) { std::string cycleStartName = allNames.back(); allNames.pop_back(); std::reverse(allNames.begin(), allNames.end()); - std::set namesInCycle = {cycleStartName}; + std::unordered_set namesInCycle = {cycleStartName}; std::string name = *allNames.begin(); while (name != cycleStartName) { namesInCycle.emplace(name); @@ -1059,7 +1060,7 @@ std::set namesInCycle(NameList allNames) bool Validator::ValidatorImpl::hasCycleAlreadyBeenReported(NameList names) const { - std::set testNamesInCycle = namesInCycle(std::move(names)); + std::unordered_set testNamesInCycle = namesInCycle(std::move(names)); bool found = false; for (size_t i = 0; !found && (i < mValidator->issueCount()); ++i) { auto issue = mValidator->issue(i); @@ -1278,14 +1279,16 @@ void Validator::ValidatorImpl::validateUnitsUnitsItem(size_t index, const UnitsP units->unitAttributes(index, reference, prefix, exponent, multiplier, id); if (isCellmlIdentifier(reference)) { ModelPtr model = owningModel(units); - if (model->hasUnits(reference) && !isStandardUnitName(reference)) { - validateUnits(model->units(reference), history, modelsVisited); - } else if (!model->hasUnits(reference) && !isStandardUnitName(reference)) { - auto issue = Issue::IssueImpl::create(); - issue->mPimpl->setDescription("Units reference '" + reference + "' in units '" + units->name() + "' is not a valid reference to a local units or a standard unit type."); - issue->mPimpl->mItem->mPimpl->setUnitsItem(UnitsItem::create(units, index)); - issue->mPimpl->setReferenceRule(Issue::ReferenceRule::UNIT_UNITS_REFERENCE); - addIssue(issue); + if (!isStandardUnitName(reference)) { + if (model->hasUnits(reference)) { + validateUnits(model->units(reference), history, modelsVisited); + } else { + auto issue = Issue::IssueImpl::create(); + issue->mPimpl->setDescription("Units reference '" + reference + "' in units '" + units->name() + "' is not a valid reference to a local units or a standard unit type."); + issue->mPimpl->mItem->mPimpl->setUnitsItem(UnitsItem::create(units, index)); + issue->mPimpl->setReferenceRule(Issue::ReferenceRule::UNIT_UNITS_REFERENCE); + addIssue(issue); + } } } else { auto issue = makeIssueIllegalIdentifier(reference); @@ -1326,12 +1329,12 @@ void Validator::ValidatorImpl::validateUnitsUnitsItem(size_t index, const UnitsP } } -void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, const NameList &variableNames) +void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, const std::unordered_set &variableNames) { ComponentPtr component = owningComponent(variable); auto variableName = variable->name(); if (!variableName.empty()) { - if (std::find(variableNames.begin(), variableNames.end(), variableName) != variableNames.end()) { + if (variableNames.count(variableName) != 0) { auto issue = Issue::IssueImpl::create(); issue->mPimpl->setDescription("Component '" + component->name() + "' contains multiple variables with the name '" + variableName + "'. Valid variable names must be unique to their component."); issue->mPimpl->mItem->mPimpl->setComponent(component); @@ -1580,12 +1583,9 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp } XmlNodePtr nodeCopy = node; - NameList variableNames; + std::unordered_set variableNames; for (size_t i = 0; i < component->variableCount(); ++i) { - std::string variableName = component->variable(i)->name(); - if (std::find(variableNames.begin(), variableNames.end(), variableName) == variableNames.end()) { - variableNames.push_back(variableName); - } + variableNames.insert(component->variable(i)->name()); } validateMathMLElements(nodeCopy, component); @@ -1710,13 +1710,13 @@ void Validator::ValidatorImpl::validateAndCleanCnNode(const XmlNodePtr &node, co } } -void Validator::ValidatorImpl::validateAndCleanCiNode(const XmlNodePtr &node, const ComponentPtr &component, const NameList &variableNames) +void Validator::ValidatorImpl::validateAndCleanCiNode(const XmlNodePtr &node, const ComponentPtr &component, const std::unordered_set &variableNames) { XmlNodePtr childNode = node->firstChild(); std::string textInNode = text(childNode); if (!textInNode.empty()) { // Check whether we can find this text as a variable name in this component. - if (std::find(variableNames.begin(), variableNames.end(), textInNode) == variableNames.end()) { + if (variableNames.count(textInNode) == 0) { auto issue = Issue::IssueImpl::create(); issue->mPimpl->setDescription("MathML ci element has the child text '" + textInNode + "' which does not correspond with any variable names present in component '" + component->name() + "'."); issue->mPimpl->mItem->mPimpl->setMath(component); @@ -1726,7 +1726,7 @@ void Validator::ValidatorImpl::validateAndCleanCiNode(const XmlNodePtr &node, co } } -void Validator::ValidatorImpl::validateAndCleanMathCiCnNodes(XmlNodePtr &node, const ComponentPtr &component, const NameList &variableNames) +void Validator::ValidatorImpl::validateAndCleanMathCiCnNodes(XmlNodePtr &node, const ComponentPtr &component, const std::unordered_set &variableNames) { if (node->isMathmlElement("cn")) { validateAndCleanCnNode(node, component); @@ -2449,8 +2449,9 @@ void Validator::ValidatorImpl::validateConnections(const ModelPtr &model) bool Validator::ValidatorImpl::isSupportedMathMLElement(const XmlNodePtr &node) const { - return (node->namespaceUri() == MATHML_NS) - && std::find(supportedMathMLElements.begin(), supportedMathMLElements.end(), node->name()) != supportedMathMLElements.end(); + static const std::unordered_set supportedMathMLElementsSet(supportedMathMLElements.begin(), supportedMathMLElements.end()); + + return node->isMathmlElement() && supportedMathMLElementsSet.count(node->rawName()) != 0; } IssuePtr Validator::ValidatorImpl::makeIssueIllegalIdentifier(const std::string &name) const @@ -2479,7 +2480,7 @@ bool unitsAreEquivalent(const ModelPtr &model, std::string &hints, double &multiplier) { - std::map unitMap = {}; + std::map unitMap; for (const auto &baseUnits : baseUnitsList) { unitMap.emplace(baseUnits, 0.0); @@ -2490,37 +2491,36 @@ bool unitsAreEquivalent(const ModelPtr &model, std::string v1UnitsName = v1->units()->name(); if (model->hasUnits(v1UnitsName)) { - UnitsPtr u1 = Units::create(); - u1 = model->units(v1UnitsName); + auto u1 = model->units(v1UnitsName); updateBaseUnitCount(model, unitMap, multiplier, u1->name(), 1, 0, 1); - } else if (unitMap.find(v1UnitsName) != unitMap.end()) { - unitMap.at(v1UnitsName) += 1.0; - } else if (isStandardUnitName(v1UnitsName)) { - updateBaseUnitCount(model, unitMap, multiplier, v1UnitsName, 1, 0, 1); + } else { + auto it = unitMap.find(v1UnitsName); + if (it != unitMap.end()) { + it->second += 1.0; + } else if (isStandardUnitName(v1UnitsName)) { + updateBaseUnitCount(model, unitMap, multiplier, v1UnitsName, 1, 0, 1); + } } std::string v2UnitsName = v2->units()->name(); if (model->hasUnits(v2UnitsName)) { - UnitsPtr u2 = Units::create(); - u2 = model->units(v2UnitsName); + auto u2 = model->units(v2UnitsName); updateBaseUnitCount(model, unitMap, multiplier, u2->name(), 1, 0, -1); - } else if (unitMap.find(v2UnitsName) != unitMap.end()) { - unitMap.at(v2UnitsName) -= 1.0; - } else if (isStandardUnitName(v2UnitsName)) { - updateBaseUnitCount(model, unitMap, multiplier, v2UnitsName, 1, 0, -1); + } else { + auto it = unitMap.find(v2UnitsName); + if (it != unitMap.end()) { + it->second -= 1.0; + } else if (isStandardUnitName(v2UnitsName)) { + updateBaseUnitCount(model, unitMap, multiplier, v2UnitsName, 1, 0, -1); + } } // Remove "dimensionless" from base unit testing. unitMap.erase("dimensionless"); - static const std::regex fullStopAtEndRegex(".$"); - bool status = true; for (const auto &basePair : unitMap) { if (basePair.second != 0.0) { - std::string num = std::to_string(basePair.second); - num.erase(num.find_last_not_of('0') + 1, num.length()); - num = std::regex_replace(num, fullStopAtEndRegex, ""); - hints += basePair.first + "^" + num + ", "; + hints += basePair.first + "^" + std::format("{}", basePair.second) + ", "; status = false; } } @@ -2529,10 +2529,7 @@ bool unitsAreEquivalent(const ModelPtr &model, // NB: multiplication issues are only reported when there is a base issue mismatch too, does not trigger it alone. // The multiplication mismatch will be returned through the multiplier argument in all cases. - std::string num = std::to_string(multiplier); - num.erase(num.find_last_not_of('0') + 1, num.length()); - num = std::regex_replace(num, fullStopAtEndRegex, ""); - hints += "multiplication factor of 10^" + num + ", "; + hints += "multiplication factor of 10^" + std::format("{}", multiplier) + ", "; } // Remove the final trailing comma from the hints string. @@ -2554,9 +2551,6 @@ void updateBaseUnitCount(const ModelPtr &model, if (model->hasUnits(uName)) { UnitsPtr u = model->units(uName); if (u->isBaseUnit()) { - if (unitMap.find(uName) == unitMap.end()) { - unitMap.emplace(uName, 0.0); - } unitMap[uName] += direction * uExp; multiplier += direction * logMult; } else { @@ -2594,7 +2588,7 @@ void Validator::ValidatorImpl::checkUniqueResetOrders(const ModelPtr &model) auto variable = variableOrder.first; auto orders = variableOrder.second; - std::set ordersSet(orders.begin(), orders.end()); + std::unordered_set ordersSet(orders.begin(), orders.end()); if (ordersSet.size() < orders.size()) { auto issue = Issue::IssueImpl::create(); @@ -2609,20 +2603,19 @@ void Validator::ValidatorImpl::checkUniqueResetOrders(const ModelPtr &model) void Validator::ValidatorImpl::addResetOrderMapItem(const VariablePtr &variable, int order, ResetOrderMap &resetOrderMap) { auto currentVariable = variable; - bool existingVariableFound = resetOrderMap.count(currentVariable) > 0; + auto it = resetOrderMap.find(currentVariable); size_t i = 0; - while ((i < variable->equivalentVariableCount()) && !existingVariableFound) { + while ((i < variable->equivalentVariableCount()) && (it == resetOrderMap.end())) { currentVariable = variable->equivalentVariable(i); - existingVariableFound = resetOrderMap.count(currentVariable) > 0; + it = resetOrderMap.find(currentVariable); ++i; } - if (existingVariableFound) { - resetOrderMap[currentVariable].emplace_back(order); + if (it != resetOrderMap.end()) { + it->second.emplace_back(order); } else { - std::vector orders = {order}; - resetOrderMap.emplace(variable, orders); + resetOrderMap.emplace(variable, std::vector {order}); } } @@ -2683,13 +2676,12 @@ void Validator::ValidatorImpl::checkUniqueIds(const ModelPtr &model) void Validator::ValidatorImpl::addIdMapItem(const std::string &id, const std::string &info, IdMap &idMap) { - if (idMap.count(id) > 0) { - idMap[id].second.emplace_back(info); - idMap[id] = std::make_pair(idMap[id].first + 1, idMap[id].second); + auto it = idMap.find(id); + if (it != idMap.end()) { + it->second.second.emplace_back(info); + ++it->second.first; } else { - Strings infos; - infos.emplace_back(info); - idMap.emplace(id, std::make_pair(1, infos)); + idMap.emplace(id, std::make_pair(1, Strings {info})); } } @@ -2716,7 +2708,7 @@ IdMap Validator::ValidatorImpl::buildModelIdMap(const ModelPtr &model) { IdMap idMap; std::string info; - std::set reportedConnections; + std::unordered_set reportedConnections; std::vector allComponents; for (size_t c = 0; c < model->componentCount(); ++c) { @@ -2801,7 +2793,7 @@ IdMap Validator::ValidatorImpl::buildModelIdMap(const ModelPtr &model) return idMap; } -void Validator::ValidatorImpl::buildComponentIdMap(const ComponentPtr &component, IdMap &idMap, std::set &reportedConnections, const ConnectionIdMap &connectionIds) +void Validator::ValidatorImpl::buildComponentIdMap(const ComponentPtr &component, IdMap &idMap, std::unordered_set &reportedConnections, const ConnectionIdMap &connectionIds) { std::string info; @@ -2812,8 +2804,9 @@ void Validator::ValidatorImpl::buildComponentIdMap(const ComponentPtr &component if (component->isImport()) { imported = "imported "; } - if (owningComponent(component) != nullptr) { - owning = "' in component '" + owningComponent(component)->name() + "'"; + auto parent = owningComponent(component); + if (parent != nullptr) { + owning = "' in component '" + parent->name() + "'"; } else { owning = "' in model '" + owningModel(component)->name() + "'"; } @@ -2885,20 +2878,20 @@ void Validator::ValidatorImpl::buildComponentIdMap(const ComponentPtr &component for (size_t i = 0; i < component->resetCount(); ++i) { auto item = component->reset(i); if (!item->id().empty()) { - info = " - reset at index " + std::to_string(i) + " in component '" + component->name() + "'"; + info = " - reset at index " + std::format("{}", i) + " in component '" + component->name() + "'"; addIdMapItem(item->id(), info, idMap); } if (!item->testValueId().empty()) { - info = " - test_value in reset at index " + std::to_string(i) + " in component '" + component->name() + "'"; + info = " - test_value in reset at index " + std::format("{}", i) + " in component '" + component->name() + "'"; addIdMapItem(item->testValueId(), info, idMap); } - info = "test_value in reset " + std::to_string(i) + " in component '" + component->name() + "'"; + info = "test_value in reset " + std::format("{}", i) + " in component '" + component->name() + "'"; buildMathIdMap(info, idMap, item->testValue()); if (!item->resetValueId().empty()) { - info = " - reset_value in reset at index " + std::to_string(i) + " in component '" + component->name() + "'"; + info = " - reset_value in reset at index " + std::format("{}", i) + " in component '" + component->name() + "'"; addIdMapItem(item->resetValueId(), info, idMap); } - info = "reset_value in reset " + std::to_string(i) + " in component '" + component->name() + "'"; + info = "reset_value in reset " + std::format("{}", i) + " in component '" + component->name() + "'"; buildMathIdMap(info, idMap, item->resetValue()); } diff --git a/src/variable.cpp b/src/variable.cpp index 06983ee978..cb8c4b8d6b 100644 --- a/src/variable.cpp +++ b/src/variable.cpp @@ -31,13 +31,13 @@ namespace libcellml { std::vector::const_iterator Variable::VariableImpl::findEquivalentVariable(const VariablePtr &equivalentVariable) const { return std::find_if(mEquivalentVariables.begin(), mEquivalentVariables.end(), - [=](const VariableWeakPtr &variableWeak) -> bool { return equivalentVariable == variableWeak.lock(); }); + [&](const VariableWeakPtr &variableWeak) -> bool { return equivalentVariable == variableWeak.lock(); }); } std::vector::iterator Variable::VariableImpl::findEquivalentVariable(const VariablePtr &equivalentVariable) { return std::find_if(mEquivalentVariables.begin(), mEquivalentVariables.end(), - [=](const VariableWeakPtr &variableWeak) -> bool { return equivalentVariable == variableWeak.lock(); }); + [&](const VariableWeakPtr &variableWeak) -> bool { return equivalentVariable == variableWeak.lock(); }); } Variable::VariableImpl *Variable::pFunc() @@ -185,7 +185,7 @@ bool Variable::hasEquivalentVariable(const VariablePtr &equivalentVariable, bool void Variable::VariableImpl::cleanExpiredVariables() { - mEquivalentVariables.erase(std::remove_if(mEquivalentVariables.begin(), mEquivalentVariables.end(), [=](const VariableWeakPtr &variableWeak) -> bool { return variableWeak.expired(); }), mEquivalentVariables.end()); + mEquivalentVariables.erase(std::remove_if(mEquivalentVariables.begin(), mEquivalentVariables.end(), [](const VariableWeakPtr &variableWeak) -> bool { return variableWeak.expired(); }), mEquivalentVariables.end()); } void Variable::VariableImpl::unsafeResetEquivalenceIds(const VariablePtr &equivalentVariable) @@ -355,7 +355,7 @@ void Variable::setInitialValue(const VariablePtr &variable) pFunc()->mInitialValue = variable->name(); } -std::string Variable::initialValue() const +const std::string &Variable::initialValue() const { return pFunc()->mInitialValue; } @@ -375,7 +375,7 @@ void Variable::setInterfaceType(Variable::InterfaceType interfaceType) setInterfaceType(interfaceTypeToString.at(interfaceType)); } -std::string Variable::interfaceType() const +const std::string &Variable::interfaceType() const { return pFunc()->mInterfaceType; } diff --git a/src/xmlattribute.cpp b/src/xmlattribute.cpp index dd5eeb2f44..d2d717279d 100644 --- a/src/xmlattribute.cpp +++ b/src/xmlattribute.cpp @@ -69,13 +69,30 @@ std::string XmlAttribute::namespacePrefix() const bool XmlAttribute::inNamespaceUri(const char *ns) const { - return xmlStrcmp(reinterpret_cast(namespaceUri().c_str()), reinterpret_cast(ns)) == 0; + if (mPimpl->mXmlAttributePtr->ns == nullptr) { + // Note: we would normally have + // return (ns == nullptr) || (ns[0] == '\0'); + // but this is an internal function and we never pass in a null pointer or an empty string for the + // namespace, so we can just return false here. + return false; + } + return xmlStrcmp(mPimpl->mXmlAttributePtr->ns->href, reinterpret_cast(ns)) == 0; } bool XmlAttribute::isType(const char *name, const char *ns) const { - return (xmlStrcmp(reinterpret_cast(namespaceUri().c_str()), reinterpret_cast(ns)) == 0) - && (xmlStrcmp(mPimpl->mXmlAttributePtr->name, reinterpret_cast(name)) == 0); + if (mPimpl->mXmlAttributePtr->ns == nullptr) { + // Note: we would normally test for + // (ns != nullptr) && (ns[0] != '\0') + // but this is an internal function and we never pass in a null pointer for the namespace, so we can just + // test for an empty string here. + if (ns[0] != '\0') { + return false; + } + } else if (xmlStrcmp(mPimpl->mXmlAttributePtr->ns->href, reinterpret_cast(ns)) != 0) { + return false; + } + return xmlStrcmp(mPimpl->mXmlAttributePtr->name, reinterpret_cast(name)) == 0; } bool XmlAttribute::isCellmlType(const char *name) const diff --git a/src/xmldoc.cpp b/src/xmldoc.cpp index 24709be463..0187f5b508 100644 --- a/src/xmldoc.cpp +++ b/src/xmldoc.cpp @@ -16,10 +16,10 @@ limitations under the License. #include "xmldoc.h" +#include #include #include #include -#include #include #include #include @@ -44,9 +44,9 @@ namespace libcellml { */ void structuredErrorCallback(void *userData, XML_ERROR_CALLBACK_ARGUMENT_TYPE error) { - static const std::regex newLineRegex("\\n"); - // Swap libxml2 carriage return for a period. - std::string errorString = std::regex_replace(error->message, newLineRegex, "."); + // Swap libxml2 newlines for a period. + std::string errorString(error->message); + std::replace(errorString.begin(), errorString.end(), '\n', '.'); auto context = reinterpret_cast(userData); auto doc = reinterpret_cast(context->_private); doc->addXmlError(errorString); diff --git a/src/xmlnode.cpp b/src/xmlnode.cpp index 93a273ac02..0d12866f8c 100644 --- a/src/xmlnode.cpp +++ b/src/xmlnode.cpp @@ -157,13 +157,14 @@ XmlNamespaceMap XmlNode::definedNamespaces() const bool XmlNode::isElement(const char *name, const char *ns) const { - bool found = false; - if ((mPimpl->mXmlNodePtr->type == XML_ELEMENT_NODE) - && (xmlStrcmp(reinterpret_cast(namespaceUri().c_str()), reinterpret_cast(ns)) == 0) - && ((name == nullptr) || (xmlStrcmp(mPimpl->mXmlNodePtr->name, reinterpret_cast(name)) == 0))) { - found = true; + if (mPimpl->mXmlNodePtr->type != XML_ELEMENT_NODE) { + return false; } - return found; + if (mPimpl->mXmlNodePtr->ns == nullptr + || xmlStrcmp(mPimpl->mXmlNodePtr->ns->href, reinterpret_cast(ns)) != 0) { + return false; + } + return (name == nullptr) || (xmlStrcmp(mPimpl->mXmlNodePtr->name, reinterpret_cast(name)) == 0); } bool XmlNode::isElement() const @@ -227,33 +228,27 @@ std::string XmlNode::name() const return reinterpret_cast(mPimpl->mXmlNodePtr->name); } -bool XmlNode::hasAttribute(const char *attributeName) const -{ - xmlAttrPtr attribute = xmlHasProp(mPimpl->mXmlNodePtr, reinterpret_cast(attributeName)); - return attribute != nullptr; -} - -xmlNsPtr getAttributeNamespace(const xmlNodePtr &node, const char *attributeName) +const char *XmlNode::rawName() const { - return xmlHasProp(node, reinterpret_cast(attributeName))->ns; + return reinterpret_cast(mPimpl->mXmlNodePtr->name); } std::string XmlNode::attribute(const char *attributeName) const { - std::string attributeValueString; - if (hasAttribute(attributeName)) { - xmlChar *attributeValue = xmlGetProp(mPimpl->mXmlNodePtr, reinterpret_cast(attributeName)); - attributeValueString = std::string(reinterpret_cast(attributeValue)); + xmlChar *attributeValue = xmlGetProp(mPimpl->mXmlNodePtr, reinterpret_cast(attributeName)); + if (attributeValue != nullptr) { + std::string result(reinterpret_cast(attributeValue)); xmlFree(attributeValue); + return result; } - return attributeValueString; + return {}; } void XmlNode::setAttribute(const char *attributeName, const char *attributeValue) { - if (hasAttribute(attributeName)) { - auto ns = getAttributeNamespace(mPimpl->mXmlNodePtr, attributeName); - xmlSetNsProp(mPimpl->mXmlNodePtr, ns, reinterpret_cast(attributeName), reinterpret_cast(attributeValue)); + xmlAttrPtr attr = xmlHasProp(mPimpl->mXmlNodePtr, reinterpret_cast(attributeName)); + if (attr != nullptr) { + xmlSetNsProp(mPimpl->mXmlNodePtr, attr->ns, reinterpret_cast(attributeName), reinterpret_cast(attributeValue)); } } @@ -320,9 +315,27 @@ std::string XmlNode::convertToString() const std::string XmlNode::convertToStrippedString() const { + // For text nodes, use xmlNodeGetContent() directly instead of going through xmlNodeDump(). xmlNodeDump() serialises + // the node as XML (creating a buffer, dumping, converting to string, and freeing) which is expensive. + // xmlNodeGetContent() returns just the text content with no serialisation overhead. + + if (isText()) { + auto *content = xmlNodeGetContent(mPimpl->mXmlNodePtr); + std::string contentString(reinterpret_cast(content)); + + xmlFree(content); + + contentString.erase(contentString.begin(), find_if_not(contentString.begin(), contentString.end(), [](int c) { return isspace(c); })); + contentString.erase(find_if_not(contentString.rbegin(), contentString.rend(), [](int c) { return isspace(c); }).base(), contentString.end()); + + return contentString; + } + std::string contentString = convertToString(); + contentString.erase(contentString.begin(), find_if_not(contentString.begin(), contentString.end(), [](int c) { return isspace(c); })); contentString.erase(find_if_not(contentString.rbegin(), contentString.rend(), [](int c) { return isspace(c); }).base(), contentString.end()); + return contentString; } diff --git a/src/xmlnode.h b/src/xmlnode.h index 0d34b1e160..9f0120e04c 100644 --- a/src/xmlnode.h +++ b/src/xmlnode.h @@ -289,18 +289,13 @@ class XmlNode std::string name() const; /** - * @brief Check if this @c XmlNode has the specified attribute. + * @brief Get the raw name of the XML element. * - * Checks whether this @c XmlNode has an attribute of the type - * specified by the argument @p attributeName. Returns @c true - * if so, and @c false otherwise. + * Get the raw name of the XML element as a C string pointer. * - * @param attributeName The @c char attribute type to check for. - * - * @return @c true if this @c XmlNode has an attribute of the type - * specified by the @p attributeName and @c false otherwise. + * @return A @c const @c char pointer to the XML element name. */ - bool hasAttribute(const char *attributeName) const; + const char *rawName() const; /** * @brief Get the attribute of the specified type for this @c XmlNode diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index b2b96add12..e03d13019f 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -67,7 +67,7 @@ configure_file( COPYONLY ) -add_library(test_utils SHARED ${TEST_UTILS_SRC} ${TEST_UTILS_HDR} ${TEST_EXPORTDEFINITIONS_H}) +add_library(test_utils ${TEST_UTILS_SRC} ${TEST_UTILS_HDR} ${TEST_EXPORTDEFINITIONS_H}) target_link_libraries(test_utils PUBLIC cellml gtest) target_include_directories(test_utils PUBLIC ${CMAKE_CURRENT_BINARY_DIR}) set_target_properties(test_utils PROPERTIES @@ -84,7 +84,8 @@ include(test_resources.cmake) if(MSVC) get_runtime_dlls_from_target(${LIBXML2_TARGET} TARGET_FILE_DIR LIBXML2_FILE_DIRS) get_runtime_dlls_from_target(${ZLIB_TARGET} TARGET_FILE_DIR ZLIB_FILE_DIRS) - set(ALL_FILE_DIRS ${LIBXML2_FILE_DIRS} ${ZLIB_FILE_DIRS}) + get_runtime_dlls_from_target(${SYMENGINE_TARGET} TARGET_FILE_DIR SYMENGINE_FILE_DIRS) + set(ALL_FILE_DIRS ${LIBXML2_FILE_DIRS} ${ZLIB_FILE_DIRS} ${SYMENGINE_FILE_DIRS}) list(REMOVE_DUPLICATES ALL_FILE_DIRS) list(JOIN ALL_FILE_DIRS "\\;" ALL_FILE_DIRS_STRING) set(ALL_FILE_DIRS_STRING "\;${ALL_FILE_DIRS_STRING}") diff --git a/tests/analyser/analyser.cpp b/tests/analyser/analyser.cpp index ecc9db714b..2671ec3520 100644 --- a/tests/analyser/analyser.cpp +++ b/tests/analyser/analyser.cpp @@ -273,11 +273,7 @@ TEST(Analyser, variableInitialisedUsingAnotherVariable) const std::vector expectedIssues = { "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 computable 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 computable 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 computable 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 computable 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 computable 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 computable non-linear algebraic variable is allowed.", }; auto analyser = libcellml::Analyser::create(); @@ -996,8 +992,6 @@ TEST(Analyser, overconstrainedNlaSystem) const std::vector expectedIssues = { "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(); @@ -1022,34 +1016,21 @@ TEST(Analyser, unsuitablyConstrainedNlaSystem) 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), diff --git a/tests/analyser/analysersymengine.cpp b/tests/analyser/analysersymengine.cpp new file mode 100644 index 0000000000..20d55ea376 --- /dev/null +++ b/tests/analyser/analysersymengine.cpp @@ -0,0 +1,528 @@ +/* +Copyright libCellML Contributors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include "test_utils.h" + +#include "gtest/gtest.h" + +#include + +TEST(AnalyserSymEngine, rearrangeAdditiveEquations) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/addition.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ALGEBRAIC, analyserModel->type()); + +#ifdef _WIN32 + EXPECT_EQ("a = 10.0-w-x", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); +#else + EXPECT_EQ("a = 10.0-x-w", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); +#endif + EXPECT_EQ("b = -1.0+y", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); + EXPECT_EQ("c = -1.0-z-x", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); + EXPECT_EQ("d = y-w", libcellml::Generator::equationCode(analyserModel->analyserEquation(3)->ast())); +} + +TEST(AnalyserSymEngine, rearrangeMultiplicativeEquations) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/multiplication.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ALGEBRAIC, analyserModel->type()); + + EXPECT_EQ("a = 4.0/w", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); + EXPECT_EQ("b = 18.0*y", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); + EXPECT_EQ("c = 30.0*x/z", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); +} + +TEST(AnalyserSymEngine, rearrangeTrigonometricEquations) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/trigonometric.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ALGEBRAIC, analyserModel->type()); + + EXPECT_EQ("a = 0.5-0.5*sin(z1)", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); + EXPECT_EQ("b = cos(4.0+z2)", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); + EXPECT_EQ("c = 2.0+tan(3.0-z3)", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); + EXPECT_EQ("d = 0.5-0.5*sec(z1)", libcellml::Generator::equationCode(analyserModel->analyserEquation(3)->ast())); + EXPECT_EQ("e = csc(4.0+z2)", libcellml::Generator::equationCode(analyserModel->analyserEquation(4)->ast())); + EXPECT_EQ("f = 2.0+cot(3.0-z3)", libcellml::Generator::equationCode(analyserModel->analyserEquation(5)->ast())); + EXPECT_EQ("g = 0.5-0.5*sinh(z1)", libcellml::Generator::equationCode(analyserModel->analyserEquation(6)->ast())); + EXPECT_EQ("h = cosh(4.0+z2)", libcellml::Generator::equationCode(analyserModel->analyserEquation(7)->ast())); + EXPECT_EQ("i = 2.0+tanh(3.0-z3)", libcellml::Generator::equationCode(analyserModel->analyserEquation(8)->ast())); + EXPECT_EQ("j = 0.5-0.5*sech(z1)", libcellml::Generator::equationCode(analyserModel->analyserEquation(9)->ast())); + EXPECT_EQ("k = csch(4.0+z2)", libcellml::Generator::equationCode(analyserModel->analyserEquation(10)->ast())); + EXPECT_EQ("l = 2.0+coth(3.0-z3)", libcellml::Generator::equationCode(analyserModel->analyserEquation(11)->ast())); + EXPECT_EQ("m = 0.5-0.5*asin(z1)", libcellml::Generator::equationCode(analyserModel->analyserEquation(12)->ast())); + EXPECT_EQ("n = acos(4.0+z2)", libcellml::Generator::equationCode(analyserModel->analyserEquation(13)->ast())); + EXPECT_EQ("o = 2.0+atan(3.0-z3)", libcellml::Generator::equationCode(analyserModel->analyserEquation(14)->ast())); + EXPECT_EQ("p = 0.5-0.5*asec(z1)", libcellml::Generator::equationCode(analyserModel->analyserEquation(15)->ast())); + EXPECT_EQ("q = acsc(4.0+z2)", libcellml::Generator::equationCode(analyserModel->analyserEquation(16)->ast())); + EXPECT_EQ("r = 2.0+acot(3.0-z3)", libcellml::Generator::equationCode(analyserModel->analyserEquation(17)->ast())); + EXPECT_EQ("s = 0.5-0.5*asinh(z1)", libcellml::Generator::equationCode(analyserModel->analyserEquation(18)->ast())); + EXPECT_EQ("t = acosh(4.0+z2)", libcellml::Generator::equationCode(analyserModel->analyserEquation(19)->ast())); + EXPECT_EQ("u = 2.0+atanh(3.0-z3)", libcellml::Generator::equationCode(analyserModel->analyserEquation(20)->ast())); + EXPECT_EQ("v = 0.5-0.5*asech(z1)", libcellml::Generator::equationCode(analyserModel->analyserEquation(21)->ast())); + EXPECT_EQ("w = acsch(4.0+z2)", libcellml::Generator::equationCode(analyserModel->analyserEquation(22)->ast())); + EXPECT_EQ("x = 2.0+acoth(3.0-z3)", libcellml::Generator::equationCode(analyserModel->analyserEquation(23)->ast())); +} + +TEST(AnalyserSymEngine, rearrangeEquationsWithConstants) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/constants.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ALGEBRAIC, analyserModel->type()); + + EXPECT_EQ("a = 8.65-x", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); + EXPECT_EQ("b = 400000.0/w", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); + EXPECT_EQ("c = y*2.71828182845905", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); +#ifdef __linux__ + EXPECT_EQ("d = 3.14159265358979+z", libcellml::Generator::equationCode(analyserModel->analyserEquation(3)->ast())); +#else + EXPECT_EQ("d = z+3.14159265358979", libcellml::Generator::equationCode(analyserModel->analyserEquation(3)->ast())); +#endif + + EXPECT_EQ("e = INFINITY-w", libcellml::Generator::equationCode(analyserModel->analyserEquation(4)->ast())); +} + +TEST(AnalyserSymEngine, rearrangePolynomialEquations) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/polynomials.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ALGEBRAIC, analyserModel->type()); + + EXPECT_EQ("a = 3.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); + EXPECT_EQ("b = -2.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); + EXPECT_EQ("c = 3.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); + EXPECT_EQ("d = pow(w, 0.333333333333333)", libcellml::Generator::equationCode(analyserModel->analyserEquation(3)->ast())); +} + +TEST(AnalyserSymEngine, rearrangeExponentialEquations) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/exponential.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ALGEBRAIC, analyserModel->type()); + + EXPECT_EQ("a = 200.0+exp(-10.0+w)", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); + EXPECT_EQ("b = -7.22597376812575e+86", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); +} + +TEST(AnalyserSymEngine, rearrangeLogarithmicEquations) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/logarithmic.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ALGEBRAIC, analyserModel->type()); + + EXPECT_EQ("a = 5.0-log(x)", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); +#ifdef _WIN32 + EXPECT_EQ("b = -y+0.477121254719662", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); +#else + EXPECT_EQ("b = 0.477121254719662-y", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); +#endif + EXPECT_EQ("c = 2.5-1.44269504088896*log(z)", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); +} + +TEST(AnalyserSymEngine, rearrangeUncommonArithmeticEquations) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/uncommon_arithmetic.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ALGEBRAIC, analyserModel->type()); + + EXPECT_EQ("a = 2.0-sqrt(w)", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); + EXPECT_EQ("b = pow(w, -0.25)", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); +#ifdef _WIN32 + EXPECT_EQ("c = 3.0*fabs(x-y)", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); +#else + EXPECT_EQ("c = 3.0*fabs(-y+x)", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); +#endif + EXPECT_EQ("d = w-ceil(0.4+x)", libcellml::Generator::equationCode(analyserModel->analyserEquation(3)->ast())); + EXPECT_EQ("e = 1.0+floor(0.5*z)", libcellml::Generator::equationCode(analyserModel->analyserEquation(4)->ast())); + EXPECT_EQ("f = 0.2*min(x, y)", libcellml::Generator::equationCode(analyserModel->analyserEquation(5)->ast())); + EXPECT_EQ("g = w/max(y, z)", libcellml::Generator::equationCode(analyserModel->analyserEquation(6)->ast())); + EXPECT_EQ("h = -fmod(z, w)", libcellml::Generator::equationCode(analyserModel->analyserEquation(7)->ast())); +} + +TEST(AnalyserSymEngine, rearrangeDifferentialEquations) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/differential.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ODE, analyserModel->type()); + + EXPECT_EQ("x = -dy/dt", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); +} + +TEST(AnalyserSymEngine, unrearrangeableEquations) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/unrearrangeable.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::NLA, analyserModel->type()); + +#ifdef _WIN32 + EXPECT_EQ("2.0*x1+sin(a)-1.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); + EXPECT_EQ("csc(4.0+b)-x2", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); + EXPECT_EQ("x1-tanh(3.0-c)-2.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); + EXPECT_EQ("sech(d)+x2-1.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(3)->ast())); + EXPECT_EQ("acos(e)-x1-0.5", libcellml::Generator::equationCode(analyserModel->analyserEquation(4)->ast())); +#else + EXPECT_EQ("sin(a)+2.0*x1-1.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); + EXPECT_EQ("-x2+csc(4.0+b)", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); + EXPECT_EQ("-tanh(3.0-c)+x1-2.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); + EXPECT_EQ("x2+sech(d)-1.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(3)->ast())); + EXPECT_EQ("-x1+acos(e)-0.5", libcellml::Generator::equationCode(analyserModel->analyserEquation(4)->ast())); +#endif + EXPECT_EQ("x2-acot(2.0+f)", libcellml::Generator::equationCode(analyserModel->analyserEquation(5)->ast())); +#ifdef _WIN32 + EXPECT_EQ("x1+asinh(g)-1.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(6)->ast())); + EXPECT_EQ("-acsch(1.0-h)-x1", libcellml::Generator::equationCode(analyserModel->analyserEquation(7)->ast())); + EXPECT_EQ("-2.0+pow(i, 2.0)-3.0*i", libcellml::Generator::equationCode(analyserModel->analyserEquation(8)->ast())); +#else + EXPECT_EQ("asinh(g)+x1-1.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(6)->ast())); + EXPECT_EQ("-x1-acsch(1.0-h)", libcellml::Generator::equationCode(analyserModel->analyserEquation(7)->ast())); + EXPECT_EQ("-2.0-3.0*i+pow(i, 2.0)", libcellml::Generator::equationCode(analyserModel->analyserEquation(8)->ast())); +#endif + EXPECT_EQ("x1-log(j)", libcellml::Generator::equationCode(analyserModel->analyserEquation(9)->ast())); + EXPECT_EQ("-0.434294481903251*log(k)+x2", libcellml::Generator::equationCode(analyserModel->analyserEquation(10)->ast())); +#ifdef _WIN32 + EXPECT_EQ("exp(l)+x1-3.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(11)->ast())); +#else + EXPECT_EQ("x1+exp(l)-3.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(11)->ast())); +#endif + EXPECT_EQ("pow(m, 2.5)-30.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(12)->ast())); + EXPECT_EQ("pow(2.0, n)-16.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(13)->ast())); + EXPECT_EQ("x2-((x1 == 0.0)?x1:o)", libcellml::Generator::equationCode(analyserModel->analyserEquation(14)->ast())); + EXPECT_EQ("x3-p*exp(p)", libcellml::Generator::equationCode(analyserModel->analyserEquation(15)->ast())); +#ifdef _WIN32 + EXPECT_EQ("fabs(q)-x1", libcellml::Generator::equationCode(analyserModel->analyserEquation(16)->ast())); +#else + EXPECT_EQ("-x1+fabs(q)", libcellml::Generator::equationCode(analyserModel->analyserEquation(16)->ast())); +#endif + EXPECT_EQ("ceil(r)-5.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(17)->ast())); +#ifdef _WIN32 + EXPECT_EQ("floor(s)+x2-3.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(18)->ast())); +#else + EXPECT_EQ("x2+floor(s)-3.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(18)->ast())); +#endif + EXPECT_EQ("x2-min(t, x1)", libcellml::Generator::equationCode(analyserModel->analyserEquation(19)->ast())); + EXPECT_EQ("-x1+max(2.0, u)-1.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(20)->ast())); + EXPECT_EQ("x2-fmod(v, 3.0)", libcellml::Generator::equationCode(analyserModel->analyserEquation(21)->ast())); +} + +TEST(AnalyserSymEngine, breakAlgebraicLoop) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/simple_capillary.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ODE, analyserModel->type()); + + EXPECT_EQ("v_y = v_in-v_z", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); + EXPECT_EQ("P_x = P_out+P_R", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); +#if defined(_WIN32) + EXPECT_EQ("v_z = -R_v*v_in/(-R_v-R)-P_C/(-R_v-R)+P_out/(-R_v-R)", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); +#elif defined(__linux__) + EXPECT_EQ("v_z = -P_C/(-R-R_v)-R_v*v_in/(-R-R_v)+P_out/(-R-R_v)", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); +#else + EXPECT_EQ("v_z = -R_v*v_in/(-R-R_v)+P_out/(-R-R_v)-P_C/(-R-R_v)", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); +#endif + EXPECT_EQ("P_R = v_z*R", libcellml::Generator::equationCode(analyserModel->analyserEquation(3)->ast())); + EXPECT_EQ("P_R_v = v_y*R_v", libcellml::Generator::equationCode(analyserModel->analyserEquation(4)->ast())); + EXPECT_EQ("dq/dt = v_y", libcellml::Generator::equationCode(analyserModel->analyserEquation(5)->ast())); + EXPECT_EQ("P_C = q/C", libcellml::Generator::equationCode(analyserModel->analyserEquation(6)->ast())); +} + +TEST(AnalyserSymEngine, breakTwoIndependentAlgebraicLoops) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/winograd_destexhe_sanchezvives_2008.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ODE, analyserModel->type()); + +#ifdef _WIN32 + EXPECT_EQ("p_1 = k_1Ca/(k_1Ca+k_2)", libcellml::Generator::equationCode(analyserModel->analyserEquation(37)->ast())); +#else + EXPECT_EQ("p_1 = k_1Ca/(k_2+k_1Ca)", libcellml::Generator::equationCode(analyserModel->analyserEquation(37)->ast())); +#endif +#if defined(_WIN32) || defined(__linux__) + EXPECT_EQ("o_1 = pow(p_C, n_exp)*alpha/(pow(p_C, n_exp)*beta+pow(p_C, n_exp)*alpha+pow(p_1, n_exp)*alpha)", libcellml::Generator::equationCode(analyserModel->analyserEquation(40)->ast())); +#else + EXPECT_EQ("o_1 = pow(p_C, n_exp)*alpha/(pow(p_C, n_exp)*alpha+pow(p_C, n_exp)*beta+pow(p_1, n_exp)*alpha)", libcellml::Generator::equationCode(analyserModel->analyserEquation(40)->ast())); +#endif +} + +TEST(AnalyserSymEngine, break2dLinearSystem) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/linear_system_2d.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ALGEBRAIC, analyserModel->type()); + + EXPECT_EQ("x = 1.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); + EXPECT_EQ("y = 2.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); +} + +TEST(AnalyserSymEngine, break3dLinearSystem) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/linear_system_3d.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ALGEBRAIC, analyserModel->type()); + + EXPECT_EQ("x = 2.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); + EXPECT_EQ("y = 1.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); + EXPECT_EQ("z = 3.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); +} + +TEST(AnalyserSymEngine, break4dLinearSystem) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/linear_system_4d.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ALGEBRAIC, analyserModel->type()); + + EXPECT_EQ("a = 2.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(0)->ast())); + EXPECT_EQ("b = 1.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(1)->ast())); + EXPECT_EQ("c = 3.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(2)->ast())); + EXPECT_EQ("d = 4.0", libcellml::Generator::equationCode(analyserModel->analyserEquation(3)->ast())); +} + +TEST(AnalyserSymEngine, intercomponentRearrangement) +{ + const std::string issue = "Given model is a CellML 1.1 model, the parser will try to represent this model in CellML 2.0."; + + auto parser = libcellml::Parser::create(false); + auto model = parser->parseModel(fileContents("analyser/symengine/capillary_network/capillary_network.cellml")); + + EXPECT_EQ(size_t(1), parser->issueCount()); + EXPECT_EQ(issue, parser->issue(0)->description()); + + auto importer = libcellml::Importer::create(false); + + importer->resolveImports(model, resourcePath("analyser/symengine/capillary_network")); + + auto importedModel = importer->flattenModel(model); + + EXPECT_EQ(size_t(0), importer->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(importedModel); + + EXPECT_EQ(libcellml::AnalyserModel::Type::ODE, analyser->analyserModel()->type()); +} + +TEST(AnalyserSymEngine, relationalAndLogicalSimplifications) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/relational_and_logical_simplifications.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->issueCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("analyser/symengine/relational_and_logical_simplifications.c", generator->implementationCode(analyserModel)); +} + +TEST(AnalyserSymEngine, arithmeticSimplifications) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/arithmetic_simplifications.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->issueCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("analyser/symengine/arithmetic_simplifications.c", generator->implementationCode(analyserModel)); +} + +TEST(AnalyserSymEngine, trigonometricSimplifications) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/trigonometric_simplifications.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->issueCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("analyser/symengine/trigonometric_simplifications.c", generator->implementationCode(analyserModel)); +} + +TEST(AnalyserSymEngine, coverage) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/symengine/coverage.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->issueCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("analyser/symengine/coverage" OS_FILE_SUFFIX ".c", generator->implementationCode(analyserModel)); +} diff --git a/tests/analyser/analyserunits.cpp b/tests/analyser/analyserunits.cpp index 0c8cc48b9d..0dc3d42f70 100644 --- a/tests/analyser/analyserunits.cpp +++ b/tests/analyser/analyserunits.cpp @@ -166,16 +166,16 @@ TEST(AnalyserUnits, eq) for (const auto &op : operators) { auto parser = libcellml::Parser::create(); - auto model = parser->parseModel(fileContents("analyser/units/" + op.first + ".cellml")); + auto model = parser->parseModel(fileContents(std::string("analyser/units/") + op.first + ".cellml")); EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "The units in 'bCst " + op.second + " 3.0' in equation 'b = bCst " + op.second + " 3.0' in component 'main' are not equivalent. 'bCst' is in 'second' while '3.0' is 'dimensionless'.", - "The units in 'cCst " + op.second + " 5.0' in equation 'c = cCst " + op.second + " 5.0' in component 'main' are not equivalent. 'cCst' is in 'volt' (i.e. 'ampere^-1 x kilogram x metre^2 x second^-3') while '5.0' is 'dimensionless'.", - "The units in 'dCst " + op.second + " 7.0' in equation 'd = dCst " + op.second + " 7.0' in component 'main' are not equivalent. 'dCst' is in 'frog' while '7.0' is 'dimensionless'.", - "The units in 'eCst " + op.second + " 9.0' in equation 'e = eCst " + op.second + " 9.0' in component 'main' are not equivalent. 'eCst' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16') while '9.0' is 'dimensionless'.", - "The units in 'fCst " + op.second + " 11.0' in equation 'f = fCst " + op.second + " 11.0' in component 'main' are not equivalent. 'fCst' is in 'second' while '11.0' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", + std::string("The units in 'bCst ") + op.second + " 3.0' in equation 'b = bCst " + op.second + " 3.0' in component 'main' are not equivalent. 'bCst' is in 'second' while '3.0' is 'dimensionless'.", + std::string("The units in 'cCst ") + op.second + " 5.0' in equation 'c = cCst " + op.second + " 5.0' in component 'main' are not equivalent. 'cCst' is in 'volt' (i.e. 'ampere^-1 x kilogram x metre^2 x second^-3') while '5.0' is 'dimensionless'.", + std::string("The units in 'dCst ") + op.second + " 7.0' in equation 'd = dCst " + op.second + " 7.0' in component 'main' are not equivalent. 'dCst' is in 'frog' while '7.0' is 'dimensionless'.", + std::string("The units in 'eCst ") + op.second + " 9.0' in equation 'e = eCst " + op.second + " 9.0' in component 'main' are not equivalent. 'eCst' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16') while '9.0' is 'dimensionless'.", + std::string("The units in 'fCst ") + op.second + " 11.0' in equation 'f = fCst " + op.second + " 11.0' in component 'main' are not equivalent. 'fCst' is in 'second' while '11.0' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", }; auto analyser = libcellml::Analyser::create(); @@ -195,16 +195,16 @@ TEST(AnalyserUnits, andOrOperators) for (const auto &op : operators) { auto parser = libcellml::Parser::create(); - auto model = parser->parseModel(fileContents("analyser/units/" + op.first + ".cellml")); + auto model = parser->parseModel(fileContents(std::string("analyser/units/") + op.first + ".cellml")); EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "The unit of 'bCst' in 'bCst " + op.second + " 3.0' in equation 'b = bCst " + op.second + " 3.0' in component 'main' is not dimensionless. 'bCst' is in 'second'.", - "The unit of 'cCst' in 'cCst " + op.second + " 5.0' in equation 'c = cCst " + op.second + " 5.0' in component 'main' is not dimensionless. 'cCst' is in 'volt' (i.e. 'ampere^-1 x kilogram x metre^2 x second^-3').", - "The unit of 'dCst' in 'dCst " + op.second + " 7.0' in equation 'd = dCst " + op.second + " 7.0' in component 'main' is not dimensionless. 'dCst' is in 'frog'.", - "The unit of 'eCst' in 'eCst " + op.second + " 9.0' in equation 'e = eCst " + op.second + " 9.0' in component 'main' is not dimensionless. 'eCst' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", - "The units of 'fCst' and '11.0' in 'fCst " + op.second + " 11.0' in equation 'f = fCst " + op.second + " 11.0' in component 'main' are not dimensionless. 'fCst' is in 'second' while '11.0' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", + std::string("The unit of 'bCst' in 'bCst ") + op.second + " 3.0' in equation 'b = bCst " + op.second + " 3.0' in component 'main' is not dimensionless. 'bCst' is in 'second'.", + std::string("The unit of 'cCst' in 'cCst ") + op.second + " 5.0' in equation 'c = cCst " + op.second + " 5.0' in component 'main' is not dimensionless. 'cCst' is in 'volt' (i.e. 'ampere^-1 x kilogram x metre^2 x second^-3').", + std::string("The unit of 'dCst' in 'dCst ") + op.second + " 7.0' in equation 'd = dCst " + op.second + " 7.0' in component 'main' is not dimensionless. 'dCst' is in 'frog'.", + std::string("The unit of 'eCst' in 'eCst ") + op.second + " 9.0' in equation 'e = eCst " + op.second + " 9.0' in component 'main' is not dimensionless. 'eCst' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", + std::string("The units of 'fCst' and '11.0' in 'fCst ") + op.second + " 11.0' in equation 'f = fCst " + op.second + " 11.0' in component 'main' are not dimensionless. 'fCst' is in 'second' while '11.0' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", }; auto analyser = libcellml::Analyser::create(); @@ -439,15 +439,15 @@ TEST(AnalyserUnits, expLnOperators) for (const auto &op : operators) { auto parser = libcellml::Parser::create(); - auto model = parser->parseModel(fileContents("analyser/units/" + op + ".cellml")); + auto model = parser->parseModel(fileContents(std::string("analyser/units/") + op + ".cellml")); EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "The unit of 'bCst' in '" + op + "(bCst)' in equation 'b = " + op + "(bCst)' in component 'main' is not dimensionless. 'bCst' is in 'second'.", - "The unit of 'cCst' in '" + op + "(cCst)' in equation 'c = " + op + "(cCst)' in component 'main' is not dimensionless. 'cCst' is in 'volt' (i.e. 'ampere^-1 x kilogram x metre^2 x second^-3').", - "The unit of 'dCst' in '" + op + "(dCst)' in equation 'd = " + op + "(dCst)' in component 'main' is not dimensionless. 'dCst' is in 'frog'.", - "The unit of 'eCst' in '" + op + "(eCst)' in equation 'e = " + op + "(eCst)' in component 'main' is not dimensionless. 'eCst' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", + std::string("The unit of 'bCst' in '") + op + "(bCst)' in equation 'b = " + op + "(bCst)' in component 'main' is not dimensionless. 'bCst' is in 'second'.", + std::string("The unit of 'cCst' in '") + op + "(cCst)' in equation 'c = " + op + "(cCst)' in component 'main' is not dimensionless. 'cCst' is in 'volt' (i.e. 'ampere^-1 x kilogram x metre^2 x second^-3').", + std::string("The unit of 'dCst' in '") + op + "(dCst)' in equation 'd = " + op + "(dCst)' in component 'main' is not dimensionless. 'dCst' is in 'frog'.", + std::string("The unit of 'eCst' in '") + op + "(eCst)' in equation 'e = " + op + "(eCst)' in component 'main' is not dimensionless. 'eCst' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", }; auto analyser = libcellml::Analyser::create(); @@ -496,15 +496,15 @@ TEST(AnalyserUnits, floorCeilingOperators) for (const auto &op : operators) { auto parser = libcellml::Parser::create(); - auto model = parser->parseModel(fileContents("analyser/units/" + op.first + ".cellml")); + auto model = parser->parseModel(fileContents(std::string("analyser/units/") + op.first + ".cellml")); EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "The units in 'b = " + op.second + "(3.0)' in component 'main' are not equivalent. 'b' is 'dimensionless' while '" + op.second + "(3.0)' is in 'second'.", - "The units in 'c = " + op.second + "(5.0)' in component 'main' are not equivalent. 'c' is 'dimensionless' while '" + op.second + "(5.0)' is in 'volt' (i.e. 'ampere^-1 x kilogram x metre^2 x second^-3').", - "The units in 'd = " + op.second + "(7.0)' in component 'main' are not equivalent. 'd' is 'dimensionless' while '" + op.second + "(7.0)' is in 'frog'.", - "The units in 'e = " + op.second + "(9.0)' in component 'main' are not equivalent. 'e' is 'dimensionless' while '" + op.second + "(9.0)' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", + std::string("The units in 'b = ") + op.second + "(3.0)' in component 'main' are not equivalent. 'b' is 'dimensionless' while '" + op.second + "(3.0)' is in 'second'.", + std::string("The units in 'c = ") + op.second + "(5.0)' in component 'main' are not equivalent. 'c' is 'dimensionless' while '" + op.second + "(5.0)' is in 'volt' (i.e. 'ampere^-1 x kilogram x metre^2 x second^-3').", + std::string("The units in 'd = ") + op.second + "(7.0)' in component 'main' are not equivalent. 'd' is 'dimensionless' while '" + op.second + "(7.0)' is in 'frog'.", + std::string("The units in 'e = ") + op.second + "(9.0)' in component 'main' are not equivalent. 'e' is 'dimensionless' while '" + op.second + "(9.0)' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", }; auto analyser = libcellml::Analyser::create(); @@ -521,17 +521,17 @@ TEST(AnalyserUnits, minMaxOperators) for (const auto &op : operators) { auto parser = libcellml::Parser::create(); - auto model = parser->parseModel(fileContents("analyser/units/" + op + ".cellml")); + auto model = parser->parseModel(fileContents(std::string("analyser/units/") + op + ".cellml")); EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "The units in '" + op + "(bCst, 3.0)' in equation 'b = " + op + "(bCst, 3.0)' in component 'main' are not equivalent. 'bCst' is in 'second' while '3.0' is 'dimensionless'.", - "The units in '" + op + "(cCst, 5.0)' in equation 'c = " + op + "(cCst, 5.0)' in component 'main' are not equivalent. 'cCst' is in 'volt' (i.e. 'ampere^-1 x kilogram x metre^2 x second^-3') while '5.0' is 'dimensionless'.", - "The units in '" + op + "(dCst, 7.0)' in equation 'd = " + op + "(dCst, 7.0)' in component 'main' are not equivalent. 'dCst' is in 'frog' while '7.0' is 'dimensionless'.", - "The units in '" + op + "(eCst, 9.0)' in equation 'e = " + op + "(eCst, 9.0)' in component 'main' are not equivalent. 'eCst' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16') while '9.0' is 'dimensionless'.", - "The units in '" + op + "(fCst, 11.0)' in equation 'f = " + op + "(fCst, 11.0)' in component 'main' are not equivalent. 'fCst' is in 'second' while '11.0' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", - "The units in '" + op + "(13.0, 15.0)' in '" + op + "(gCst, " + op + "(13.0, 15.0))' in equation 'g = " + op + "(gCst, " + op + "(13.0, 15.0))' in component 'main' are not equivalent. '13.0' is in 'frog' while '15.0' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", + std::string("The units in '") + op + "(bCst, 3.0)' in equation 'b = " + op + "(bCst, 3.0)' in component 'main' are not equivalent. 'bCst' is in 'second' while '3.0' is 'dimensionless'.", + std::string("The units in '") + op + "(cCst, 5.0)' in equation 'c = " + op + "(cCst, 5.0)' in component 'main' are not equivalent. 'cCst' is in 'volt' (i.e. 'ampere^-1 x kilogram x metre^2 x second^-3') while '5.0' is 'dimensionless'.", + std::string("The units in '") + op + "(dCst, 7.0)' in equation 'd = " + op + "(dCst, 7.0)' in component 'main' are not equivalent. 'dCst' is in 'frog' while '7.0' is 'dimensionless'.", + std::string("The units in '") + op + "(eCst, 9.0)' in equation 'e = " + op + "(eCst, 9.0)' in component 'main' are not equivalent. 'eCst' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16') while '9.0' is 'dimensionless'.", + std::string("The units in '") + op + "(fCst, 11.0)' in equation 'f = " + op + "(fCst, 11.0)' in component 'main' are not equivalent. 'fCst' is in 'second' while '11.0' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", + std::string("The units in '") + op + "(13.0, 15.0)' in '" + op + "(gCst, " + op + "(13.0, 15.0))' in equation 'g = " + op + "(gCst, " + op + "(13.0, 15.0))' in component 'main' are not equivalent. '13.0' is in 'frog' while '15.0' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", }; auto analyser = libcellml::Analyser::create(); @@ -570,15 +570,15 @@ TEST(AnalyserUnits, trigonometricOperators) for (const auto &op : operators) { auto parser = libcellml::Parser::create(); - auto model = parser->parseModel(fileContents("analyser/units/" + op + ".cellml")); + auto model = parser->parseModel(fileContents(std::string("analyser/units/") + op + ".cellml")); EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "The unit of '3.0' in '" + op + "(3.0)' in equation 'b = " + op + "(3.0)' in component 'main' is not dimensionless. '3.0' is in 'second'.", - "The unit of '5.0' in '" + op + "(5.0)' in equation 'c = " + op + "(5.0)' in component 'main' is not dimensionless. '5.0' is in 'volt' (i.e. 'ampere^-1 x kilogram x metre^2 x second^-3').", - "The unit of '7.0' in '" + op + "(7.0)' in equation 'd = " + op + "(7.0)' in component 'main' is not dimensionless. '7.0' is in 'frog'.", - "The unit of '9.0' in '" + op + "(9.0)' in equation 'e = " + op + "(9.0)' in component 'main' is not dimensionless. '9.0' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", + std::string("The unit of '3.0' in '") + op + "(3.0)' in equation 'b = " + op + "(3.0)' in component 'main' is not dimensionless. '3.0' is in 'second'.", + std::string("The unit of '5.0' in '") + op + "(5.0)' in equation 'c = " + op + "(5.0)' in component 'main' is not dimensionless. '5.0' is in 'volt' (i.e. 'ampere^-1 x kilogram x metre^2 x second^-3').", + std::string("The unit of '7.0' in '") + op + "(7.0)' in equation 'd = " + op + "(7.0)' in component 'main' is not dimensionless. '7.0' is in 'frog'.", + std::string("The unit of '9.0' in '") + op + "(9.0)' in equation 'e = " + op + "(9.0)' in component 'main' is not dimensionless. '9.0' is in 'imaginary' (i.e. '10^-30 x ampere^-6 x frog^10 x kilogram^6 x metre^12 x second^-16').", }; auto analyser = libcellml::Analyser::create(); @@ -651,7 +651,7 @@ TEST(AnalyserUnits, rhs) EXPECT_EQ_ISSUES(expectedIssues, analyser); } -TEST(AnaylserUnits, compoundEquivalentUnits) +TEST(AnalyserUnits, compoundEquivalentUnits) { auto m = libcellml::Model::create("compound_units"); auto c = libcellml::Component::create("main"); @@ -701,7 +701,7 @@ TEST(AnaylserUnits, compoundEquivalentUnits) EXPECT_EQ(size_t(0), analyser->warningCount()); } -TEST(AnaylserUnits, compoundEquivalentUnitsMismatch) +TEST(AnalyserUnits, compoundEquivalentUnitsMismatch) { const std::vector expectedIssues = { "The units in 'a = o' in component 'main' are not equivalent. 'a' is in 'apple' (i.e. 'kilogram x metre^2 x second^-2') while 'o' is in 'orange' (i.e. 'ampere^-2 x kilogram x metre^5 x second^-3').", @@ -883,10 +883,6 @@ TEST(AnalyserUnits, powerValues) "The units in 'eqnPi = pow(x, pi)' in component 'my_component' are not equivalent. 'eqnPi' is in 'second' while 'pow(x, pi)' is in 'second^3.14159'.", "The units in 'eqnInfinity = pow(x, infinity)' in component 'my_component' are not equivalent. 'eqnInfinity' is in 'second' while 'pow(x, infinity)' is in 'second^inf' (i.e. '10^nan x second^inf').", "The units in 'eqnNotanumber = pow(x, notanumber)' in component 'my_component' are not equivalent. 'eqnNotanumber' is in 'second' while 'pow(x, notanumber)' is in 'second^nan' (i.e. '10^nan x second^nan').", - "The type of variable 'u' in component 'my_component' is unknown.", - "The type of variable 'eqnCoverage' in component 'my_component' is unknown.", - "The type of variable 'eqnCoverage2' in component 'my_component' is unknown.", - "The type of variable 'eqnCoverage3' in component 'my_component' is unknown.", }; auto analyser = libcellml::Analyser::create(); diff --git a/tests/analyser/tests.cmake b/tests/analyser/tests.cmake index ab22b635e5..b755dce4a3 100644 --- a/tests/analyser/tests.cmake +++ b/tests/analyser/tests.cmake @@ -6,5 +6,6 @@ list(APPEND LIBCELLML_TESTS ${CURRENT_TEST}) set(${CURRENT_TEST}_SRCS ${CMAKE_CURRENT_LIST_DIR}/analyser.cpp ${CMAKE_CURRENT_LIST_DIR}/analyserexternalvariable.cpp + ${CMAKE_CURRENT_LIST_DIR}/analysersymengine.cpp ${CMAKE_CURRENT_LIST_DIR}/analyserunits.cpp ) diff --git a/tests/api_headers/api_header_test.in.cmake b/tests/api_headers/api_header_test.in.cmake index bc94cb6417..ca6aaf6ee3 100644 --- a/tests/api_headers/api_header_test.in.cmake +++ b/tests/api_headers/api_header_test.in.cmake @@ -10,9 +10,9 @@ set_target_properties(${CURRENT_TEST} PROPERTIES add_test(NAME api_header_inclusion_${CURRENT_TEST} COMMAND ${CURRENT_TEST}) if(MSVC) - # The libxml2 DLL and zlib DLL must be on the path otherwise the tests will not be able to run. + # The libxml2 DLL, SymEngine DLL, and zlib DLL must be on the path otherwise the tests will not be able to run. set_tests_properties(api_header_inclusion_${CURRENT_TEST} - PROPERTIES ENVIRONMENT "PATH=$\;$${GEN_EXP_XML2_TARGET_FILE_DIR}${GEN_EXP_ZLIB_TARGET_FILE_DIR}") + PROPERTIES ENVIRONMENT "PATH=$\;$${GEN_EXP_XML2_TARGET_FILE_DIR}${GEN_EXP_SYMENGINE_TARGET_FILE_DIR}${GEN_EXP_ZLIB_TARGET_FILE_DIR}") endif() list(APPEND TEST_LIST ${CURRENT_TEST}) diff --git a/tests/bindings/python/test_analyser.py b/tests/bindings/python/test_analyser.py index 0f9324bf91..c97be0b88e 100644 --- a/tests/bindings/python/test_analyser.py +++ b/tests/bindings/python/test_analyser.py @@ -226,6 +226,7 @@ def test_coverage(self): aea.setParent(aea) aea.setLeftChild(None) aea.setRightChild(None) + aea.clone() self.assertEqual(AnalyserEquationAst.Type.EQ, aea.type()) self.assertEqual("eq", AnalyserEquationAst.typeAsString(aea.type())) diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index 3a8aa192e5..3f0455e2a1 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -512,7 +512,7 @@ TEST(Coverage, analyser) model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml")); - analyser->addExternalVariable(libcellml::AnalyserExternalVariable::create(model->component("membrane")->variable("V"))); + EXPECT_TRUE(analyser->addExternalVariable(libcellml::AnalyserExternalVariable::create(model->component("membrane")->variable("V")))); analyser->analyseModel(model); @@ -589,6 +589,123 @@ TEST(Coverage, analyserTypes) EXPECT_EQ("algebraic_variable", libcellml::AnalyserVariable::typeAsString(analyserModel->algebraicVariable(0)->type())); } +TEST(Coverage, analyserEquationAstClone) +{ + auto ast = libcellml::AnalyserEquationAst::create(); + + ast->setType(libcellml::AnalyserEquationAst::Type::PLUS); + + auto leftChild = libcellml::AnalyserEquationAst::create(); + + leftChild->setType(libcellml::AnalyserEquationAst::Type::CN); + leftChild->setValue("1.0"); + + auto rightChild = libcellml::AnalyserEquationAst::create(); + + rightChild->setType(libcellml::AnalyserEquationAst::Type::CN); + rightChild->setValue("2.0"); + + ast->setLeftChild(leftChild); + ast->setRightChild(rightChild); + + ast->clone(); + + auto cloned = ast->clone(); + + EXPECT_EQ(libcellml::AnalyserEquationAst::Type::PLUS, cloned->type()); + + auto clonedLeftChild = cloned->leftChild(); + + EXPECT_NE(nullptr, clonedLeftChild); + EXPECT_EQ(libcellml::AnalyserEquationAst::Type::CN, clonedLeftChild->type()); + EXPECT_EQ("1.0", clonedLeftChild->value()); + + auto clonedRightChild = cloned->rightChild(); + + EXPECT_NE(nullptr, clonedRightChild); + EXPECT_EQ(libcellml::AnalyserEquationAst::Type::CN, clonedRightChild->type()); + EXPECT_EQ("2.0", clonedRightChild->value()); +} + +TEST(Coverage, analyserWithNlaExternalVariable) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("coverage/generator/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + auto externalNlaVariable = libcellml::AnalyserExternalVariable::create(model->component("my_component")->variable("eqnNlaVariable1")); + + externalNlaVariable->addDependency(model->component("my_component")->variable("x")); + + EXPECT_TRUE(analyser->addExternalVariable(externalNlaVariable)); + EXPECT_TRUE(analyser->addExternalVariable(model->component("my_component")->variable("eqnNlaVariable2"))); + EXPECT_TRUE(analyser->addExternalVariable(model->component("my_component")->variable("x"))); + + analyser->analyseModel(model); + + EXPECT_NE(nullptr, analyser->analyserModel()); +} + +TEST(Coverage, analyserWithOverconstrainedNlaBasedModel) +{ + const std::string modelString = + "\n" + "\n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " t\n" + " x\n" + " \n" + " 1\n" + " \n" + " \n" + " \n" + " \n" + " \n" + " x\n" + " a\n" + " \n" + " 1\n" + " \n" + " \n" + " \n" + " \n" + " \n" + " x\n" + " a\n" + " \n" + " 0.5\n" + " \n" + " \n" + " \n" + "\n"; + + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(modelString); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserModel::Type::OVERCONSTRAINED, analyserModel->type()); +} + TEST(Coverage, analyserAreEquivalentVariables) { auto analyser = libcellml::Analyser::create(); @@ -598,8 +715,11 @@ TEST(Coverage, analyserAreEquivalentVariables) analyser->analyseModel(model); auto analyserModel = analyser->analyserModel(); + EXPECT_FALSE(analyserModel->areEquivalentVariables(nullptr, nullptr)); + auto variable = model->component("membrane")->variable("V"); + EXPECT_FALSE(analyserModel->areEquivalentVariables(nullptr, variable)); EXPECT_FALSE(analyserModel->areEquivalentVariables(variable, nullptr)); auto otherVariable = libcellml::Variable::create("other"); @@ -627,7 +747,7 @@ TEST(Coverage, generator) auto analyser = libcellml::Analyser::create(); - analyser->addExternalVariable(libcellml::AnalyserExternalVariable::create(model->component("my_component")->variable("eqnPlus"))); + EXPECT_TRUE(analyser->addExternalVariable(libcellml::AnalyserExternalVariable::create(model->component("my_component")->variable("eqnPlus")))); analyser->analyseModel(model); @@ -640,10 +760,10 @@ TEST(Coverage, generator) EXPECT_EQ(size_t(1), analyserModel->stateCount()); EXPECT_EQ(size_t(7), analyserModel->constantCount()); - EXPECT_EQ(size_t(199), analyserModel->computedConstantCount()); + EXPECT_EQ(size_t(200), analyserModel->computedConstantCount()); EXPECT_EQ(size_t(2), analyserModel->algebraicVariableCount()); EXPECT_EQ(size_t(1), analyserModel->externalVariableCount()); - EXPECT_EQ(size_t(203), analyserModel->analyserEquationCount()); + EXPECT_EQ(size_t(204), analyserModel->analyserEquationCount()); EXPECT_NE(nullptr, analyserModel->voi()); EXPECT_EQ(size_t(0), analyserModel->voi()->analyserEquationCount()); @@ -668,7 +788,7 @@ TEST(Coverage, generator) EXPECT_EQ(nullptr, analyserModel->algebraicVariable(analyserModel->algebraicVariableCount())); EXPECT_NE(nullptr, analyserModel->externalVariable(0)); EXPECT_NE(nullptr, analyserModel->externalVariable(0)->analyserEquation(0)->externalVariable(0)); - EXPECT_EQ(nullptr, analyserModel->externalVariable(analyserModel->algebraicVariableCount())); + EXPECT_EQ(nullptr, analyserModel->externalVariable(analyserModel->externalVariableCount())); EXPECT_EQ(size_t(1), analyserModel->analyserEquation(0)->stateCount()); EXPECT_EQ(size_t(1), analyserModel->analyserEquation(0)->states().size()); EXPECT_NE(nullptr, analyserModel->analyserEquation(0)->state(0)); @@ -718,7 +838,7 @@ TEST(Coverage, generator) } for (size_t i = 0; i < analyserModel->algebraicVariableCount(); ++i) { - EXPECT_NE(nullptr, analyserModel->algebraicVariable(i)->initialisingVariable()); + EXPECT_EQ(nullptr, analyserModel->algebraicVariable(i)->initialisingVariable()); } EXPECT_EQ(EMPTY_STRING, generator->interfaceCode(nullptr)); @@ -727,7 +847,7 @@ TEST(Coverage, generator) auto profile = libcellml::GeneratorProfile::create(); EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.h", generator->interfaceCode(analyserModel, profile, generatorVariableTracker)); - EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.c", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model" OS_FILE_SUFFIX ".c", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); profile->setInterfaceCreateStatesArrayMethodString("double * createStatesVector();\n"); profile->setImplementationCreateStatesArrayMethodString("double * createStatesVector()\n" @@ -742,7 +862,7 @@ TEST(Coverage, generator) "}\n"); EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.modified.profile.h", generator->interfaceCode(analyserModel, profile, generatorVariableTracker)); - EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.modified.profile.c", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.modified.profile" OS_FILE_SUFFIX ".c", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); profile = libcellml::GeneratorProfile::create(); @@ -811,7 +931,7 @@ TEST(Coverage, generator) profile->setImplementationComputeVariablesMethodString(true, true, ""); EXPECT_EQ(EMPTY_STRING, generator->interfaceCode(analyserModel, profile)); - EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.out", generator->implementationCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model" OS_FILE_SUFFIX ".out", generator->implementationCode(analyserModel, profile)); profile = libcellml::GeneratorProfile::create(); @@ -883,19 +1003,19 @@ TEST(Coverage, generator) profile->setVariableInfoEntryString(""); EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.interface.out", generator->interfaceCode(analyserModel, profile)); - EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.implementation.out", generator->implementationCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.implementation" OS_FILE_SUFFIX ".out", generator->implementationCode(analyserModel, profile)); profile->setProfile(libcellml::GeneratorProfile::Profile::PYTHON); EXPECT_EQ(EMPTY_STRING, generator->interfaceCode(analyserModel, profile)); - EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.py", generator->implementationCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model" OS_FILE_SUFFIX ".py", generator->implementationCode(analyserModel, profile)); profile->setImplementationCreateStatesArrayMethodString("\n" "def create_states_vector():\n" " return [nan]*STATE_COUNT\n"); EXPECT_EQ(EMPTY_STRING, generator->interfaceCode(analyserModel, profile)); - EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.modified.profile.py", generator->implementationCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.modified.profile" OS_FILE_SUFFIX ".py", generator->implementationCode(analyserModel, profile)); // Coverage for the case where we pass a null profile. @@ -904,7 +1024,7 @@ TEST(Coverage, generator) // Coverage for various profile settings. - analyser->addExternalVariable(libcellml::AnalyserExternalVariable::create(model->component("my_component")->variable("eqnEq"))); + EXPECT_TRUE(analyser->addExternalVariable(libcellml::AnalyserExternalVariable::create(model->component("my_component")->variable("eqnEq")))); analyser->analyseModel(model); @@ -985,6 +1105,31 @@ TEST(Coverage, generator) libcellml::Generator::equationCode(analyser->analyserModel()->analyserEquation(0)->ast()); } +TEST(Coverage, generatorVersionString) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("coverage/generator/model.cellml")); + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + auto profile = libcellml::GeneratorProfile::create(); + + profile->setImplementationVersionString("const char VERSION[] = \".\";\n"); + + generator->implementationCode(analyserModel, profile); + + profile->setImplementationVersionString("const char VERSION[] = \"0.0.0.0\";\n"); + + generator->implementationCode(analyserModel, profile); + + profile->setImplementationVersionString("const char VERSION[] = \"0.0.0"); + + generator->implementationCode(analyserModel, profile); +} + TEST(Coverage, generatorWithNoTracking) { auto parser = libcellml::Parser::create(); @@ -1000,7 +1145,7 @@ TEST(Coverage, generatorWithNoTracking) generatorVariableTracker->untrackAllVariables(analyserModel); EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.no.tracking.h", generator->interfaceCode(analyserModel, generatorVariableTracker)); - EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.no.tracking.c", generator->implementationCode(analyserModel, generatorVariableTracker)); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.no.tracking" OS_FILE_SUFFIX ".c", generator->implementationCode(analyserModel, generatorVariableTracker)); } TEST(CoverageValidator, degreeElementWithOneSibling) @@ -1173,3 +1318,17 @@ TEST(CoverageModelFlattening, componentWithMathThatIsNotMathML) auto flattenedModel = importer->flattenModel(model); EXPECT_EQ(size_t(1), flattenedModel->unitsCount()); } + +TEST(PrinterCoverage, printMath) +{ + auto model = libcellml::Model::create("model"); + auto component = libcellml::Component::create("component"); + + model->addComponent(component); + + auto printer = libcellml::Printer::create(); + + component->setMath("printModel(model); +} diff --git a/tests/equality/equality.cpp b/tests/equality/equality.cpp index 985af49631..5743e9f057 100644 --- a/tests/equality/equality.cpp +++ b/tests/equality/equality.cpp @@ -347,7 +347,7 @@ TEST(Equality, unitsEqualPrecision1) libcellml::UnitsPtr u2 = libcellml::Units::create("unitsA"); u1->addUnit("second", 1.0); - u2->addUnit("second", 1.0 + std::numeric_limits::epsilon()); + u2->addUnit("second", 1.0 + 0.5 * epsilon()); EXPECT_TRUE(u1->equals(u2)); EXPECT_TRUE(u2->equals(u1)); @@ -359,7 +359,7 @@ TEST(Equality, unitsEqualPrecision2) libcellml::UnitsPtr u2 = libcellml::Units::create("unitsA"); u1->addUnit("second", 1.0); - u2->addUnit("second", 1.0 + 2 * std::numeric_limits::epsilon()); + u2->addUnit("second", 1.0 + 1.5 * epsilon()); EXPECT_FALSE(u1->equals(u2)); EXPECT_FALSE(u2->equals(u1)); diff --git a/tests/generator/generator.cpp b/tests/generator/generator.cpp index 13af89e313..66e00257b5 100644 --- a/tests/generator/generator.cpp +++ b/tests/generator/generator.cpp @@ -277,11 +277,11 @@ TEST(Generator, algebraicEqnWithOneNonIsolatedUnknown) auto generator = libcellml::Generator::create(); EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.h", generator->interfaceCode(analyserModel)); - EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.c", generator->implementationCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model" OS_FILE_SUFFIX ".c", generator->implementationCode(analyserModel)); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); - EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.py", generator->implementationCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model" OS_FILE_SUFFIX ".py", generator->implementationCode(analyserModel, profile)); } TEST(Generator, algebraicEqnWithOneNonIsolatedUnknownWithExternalVariable) @@ -307,11 +307,11 @@ TEST(Generator, algebraicEqnWithOneNonIsolatedUnknownWithExternalVariable) profile->setInterfaceFileNameString("model.external.h"); EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h", generator->interfaceCode(analyserModel, profile)); - EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c", generator->implementationCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.external" OS_FILE_SUFFIX ".c", generator->implementationCode(analyserModel, profile)); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); - EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py", generator->implementationCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.external" OS_FILE_SUFFIX ".py", generator->implementationCode(analyserModel, profile)); } TEST(Generator, algebraicSystemWithThreeLinkedUnknowns) @@ -1397,13 +1397,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952WithVariousExternalVariables) EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.external.py", generator->implementationCode(analyserModel, profile)); } -TEST(Generator, hodgkinHuxleySquidAxonModel195Dae) +TEST(Generator, hodgkinHuxleySquidAxonModel195Variant) { - // Same as the hodgkinHuxleySquidAxonModel1952 test, except that all the - // algebraic equations are to be computed using NLA systems of one equation. + // Same as the hodgkinHuxleySquidAxonModel1952 test, except that all the equations have been rearranged to force the + // analyser to do more work to figure out how to compute things and to make sure that the generated code is correct + // in such a case. auto parser = libcellml::Parser::create(); - auto model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.cellml")); + auto model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.variant.cellml")); EXPECT_EQ(size_t(0), parser->issueCount()); @@ -1418,14 +1419,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel195Dae) auto profile = libcellml::GeneratorProfile::create(); - profile->setInterfaceFileNameString("model.dae.h"); + profile->setInterfaceFileNameString("model.variant.h"); - EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h", generator->interfaceCode(analyserModel, profile)); - EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c", generator->implementationCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.variant.h", generator->interfaceCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.variant" OS_FILE_SUFFIX ".c", generator->implementationCode(analyserModel, profile)); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); - EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py", generator->implementationCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.variant" OS_FILE_SUFFIX ".py", generator->implementationCode(analyserModel, profile)); } TEST(Generator, hodgkinHuxleySquidAxonModel1952DaeWithVariousExternalVariables) @@ -1433,7 +1434,7 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952DaeWithVariousExternalVariables) // Same as hodgkinHuxleySquidAxonModel1952WithVariousExternalVariables but with the DAE version of the HH52 model. auto parser = libcellml::Parser::create(); - auto model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.cellml")); + auto model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.variant.cellml")); EXPECT_EQ(size_t(0), parser->issueCount()); @@ -1457,14 +1458,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952DaeWithVariousExternalVariables) auto profile = libcellml::GeneratorProfile::create(); - profile->setInterfaceFileNameString("model.dae.external.h"); + profile->setInterfaceFileNameString("model.variant.external.h"); - EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h", generator->interfaceCode(analyserModel, profile)); - EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c", generator->implementationCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external.h", generator->interfaceCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external" OS_FILE_SUFFIX ".c", generator->implementationCode(analyserModel, profile)); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); - EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py", generator->implementationCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external" OS_FILE_SUFFIX ".py", generator->implementationCode(analyserModel, profile)); } TEST(Generator, nobleModel1962) @@ -1540,11 +1541,11 @@ TEST(Generator, robertsonDaeModel1966) profile->setInterfaceFileNameString("model.dae.h"); EXPECT_EQ_FILE_CONTENTS("generator/robertson_model_1966/model.dae.h", generator->interfaceCode(analyserModel, profile)); - EXPECT_EQ_FILE_CONTENTS("generator/robertson_model_1966/model.dae.c", generator->implementationCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("generator/robertson_model_1966/model.dae" OS_FILE_SUFFIX ".c", generator->implementationCode(analyserModel, profile)); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); - EXPECT_EQ_FILE_CONTENTS("generator/robertson_model_1966/model.dae.py", generator->implementationCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("generator/robertson_model_1966/model.dae" OS_FILE_SUFFIX ".py", generator->implementationCode(analyserModel, profile)); } TEST(Generator, sineImports) @@ -1755,6 +1756,28 @@ TEST(Generator, generateCodeUsingProfileEnum) EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_computed_var_on_rhs/model.py", generator->implementationCode(analyserModel, libcellml::GeneratorProfile::Profile::PYTHON)); } +TEST(Generator, generateCodeForModelsWithGlobalNlaSystems) +{ + auto parser = libcellml::Parser::create(false); + auto model = parser->parseModel(fileContents("generator/global_nla_systems/model.cellml")); + + EXPECT_EQ(size_t(0), parser->errorCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->issueCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("generator/global_nla_systems/model.h", generator->interfaceCode(analyserModel, libcellml::GeneratorProfile::Profile::C)); + EXPECT_EQ_FILE_CONTENTS("generator/global_nla_systems/model" OS_FILE_SUFFIX ".c", generator->implementationCode(analyserModel, libcellml::GeneratorProfile::Profile::C)); + + EXPECT_EQ_FILE_CONTENTS("generator/global_nla_systems/model" OS_FILE_SUFFIX ".py", generator->implementationCode(analyserModel, libcellml::GeneratorProfile::Profile::PYTHON)); +} + TEST(Generator, checkGeneratorReleasesAnalyserModel) { auto parser = libcellml::Parser::create(); diff --git a/tests/generator/generatorvariabletracker.cpp b/tests/generator/generatorvariabletracker.cpp index b7ac79f255..f74a82d909 100644 --- a/tests/generator/generatorvariabletracker.cpp +++ b/tests/generator/generatorvariabletracker.cpp @@ -453,7 +453,7 @@ enum class TrackingType VARIABLES, CONSTANTS, COMPUTED_CONSTANTS, - ALGEBRAIC + ALGEBRAIC_VARIABLES }; void untrack(const libcellml::AnalyserModelPtr &analyserModel, const libcellml::GeneratorVariableTrackerPtr &generatorVariableTracker, TrackingType trackingType) @@ -472,7 +472,7 @@ void untrack(const libcellml::AnalyserModelPtr &analyserModel, const libcellml:: generatorVariableTracker->untrackAllComputedConstants(analyserModel); break; - case TrackingType::ALGEBRAIC: + case TrackingType::ALGEBRAIC_VARIABLES: generatorVariableTracker->untrackAllAlgebraicVariables(analyserModel); break; @@ -481,7 +481,7 @@ void untrack(const libcellml::AnalyserModelPtr &analyserModel, const libcellml:: } } -void hodgkinHuxleySquidAxonModel1952CodeGeneration(bool ode, TrackingType trackingType, +void hodgkinHuxleySquidAxonModel1952CodeGeneration(bool original, TrackingType trackingType, const std::vector &issues, const std::vector &levels, const std::vector &referenceRules, @@ -490,20 +490,20 @@ void hodgkinHuxleySquidAxonModel1952CodeGeneration(bool ode, TrackingType tracki const std::vector &externalReferenceRules) { auto parser = libcellml::Parser::create(); - auto model = parser->parseModel(fileContents(std::string("generator/hodgkin_huxley_squid_axon_model_1952/model") + (ode ? "" : ".dae.for.tracking") + ".cellml")); + auto model = parser->parseModel(fileContents(std::string("generator/hodgkin_huxley_squid_axon_model_1952/model") + (original ? "" : ".variant") + ".cellml")); auto analyser = libcellml::Analyser::create(); auto generator = libcellml::Generator::create(); auto generatorVariableTracker = libcellml::GeneratorVariableTracker::create(); - std::string modelType = ode ? "model" : "model.dae.for.tracking"; + std::string modelType = "model" + std::string(original ? "" : ".variant"); std::string variableType = (trackingType == TrackingType::VARIABLES) ? "untracked.variables" : ((trackingType == TrackingType::CONSTANTS) ? "untracked.constants" : ((trackingType == TrackingType::COMPUTED_CONSTANTS) ? "untracked.computed.constants" : - ((trackingType == TrackingType::ALGEBRAIC) ? + ((trackingType == TrackingType::ALGEBRAIC_VARIABLES) ? "untracked.algebraic.variables" : - "control"))); + "untracked.control"))); analyser->analyseModel(model); @@ -518,11 +518,11 @@ void hodgkinHuxleySquidAxonModel1952CodeGeneration(bool ode, TrackingType tracki profile->setInterfaceFileNameString(modelType + "." + variableType + ".h"); EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/" + modelType + "." + variableType + ".h", generator->interfaceCode(analyserModel, profile, generatorVariableTracker)); - EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/" + modelType + "." + variableType + ".c", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/" + modelType + "." + variableType + (original ? "" : OS_FILE_SUFFIX) + ".c", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); - EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/" + modelType + "." + variableType + ".py", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/" + modelType + "." + variableType + (original ? "" : OS_FILE_SUFFIX) + ".py", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); // With an external variable with a dependency on a constant, computed constant, and algebraic variable. @@ -550,175 +550,68 @@ void hodgkinHuxleySquidAxonModel1952CodeGeneration(bool ode, TrackingType tracki profile->setInterfaceFileNameString(modelType + "." + variableType + ".with.externals.h"); EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/" + modelType + "." + variableType + ".with.externals.h", generator->interfaceCode(analyserModel, profile, generatorVariableTracker)); - EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/" + modelType + "." + variableType + ".with.externals.c", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/" + modelType + "." + variableType + ".with.externals" + (original ? "" : OS_FILE_SUFFIX) + ".c", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); - EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/" + modelType + "." + variableType + ".with.externals.py", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/" + modelType + "." + variableType + ".with.externals" + (original ? "" : OS_FILE_SUFFIX) + ".py", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); +} + +void hodgkinHuxleySquidAxonModel1952CodeGenerationTests(TrackingType trackingType, + const std::vector &issues, + const std::vector &levels, + const std::vector &referenceRules, + const std::vector &externalIssues, + const std::vector &externalLevels, + const std::vector &externalReferenceRules) +{ + hodgkinHuxleySquidAxonModel1952CodeGeneration(true, trackingType, issues, levels, referenceRules, externalIssues, externalLevels, externalReferenceRules); + hodgkinHuxleySquidAxonModel1952CodeGeneration(false, trackingType, issues, levels, referenceRules, externalIssues, externalLevels, externalReferenceRules); } TEST(GeneratorVariableTracker, hodgkinHuxleySquidAxonModel1952Control) { - hodgkinHuxleySquidAxonModel1952CodeGeneration(true, TrackingType::CONSTANTS, - {}, {}, {}, - {"Variable 'Cm' in component 'membrane' is needed to compute an external variable and cannot therefore be untracked."}, - {libcellml::Issue::Level::ERROR}, - {libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE}); + hodgkinHuxleySquidAxonModel1952CodeGenerationTests(TrackingType::CONTROL, + {}, {}, {}, + {}, {}, {}); } TEST(GeneratorVariableTracker, hodgkinHuxleySquidAxonModel1952UntrackedConstants) { - hodgkinHuxleySquidAxonModel1952CodeGeneration(true, TrackingType::CONSTANTS, - {}, {}, {}, - {"Variable 'Cm' in component 'membrane' is needed to compute an external variable and cannot therefore be untracked."}, - {libcellml::Issue::Level::ERROR}, - {libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE}); + hodgkinHuxleySquidAxonModel1952CodeGenerationTests(TrackingType::CONSTANTS, + {}, {}, {}, + {"Variable 'Cm' in component 'membrane' is needed to compute an external variable and cannot therefore be untracked."}, + {libcellml::Issue::Level::ERROR}, + {libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE}); } TEST(GeneratorVariableTracker, hodgkinHuxleySquidAxonModel1952UntrackedComputedConstants) { - hodgkinHuxleySquidAxonModel1952CodeGeneration(true, TrackingType::COMPUTED_CONSTANTS, - {}, {}, {}, - {"Variable 'E_K' in component 'potassium_channel' is needed to compute an external variable and cannot therefore be untracked."}, - {libcellml::Issue::Level::ERROR}, - {libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE}); + hodgkinHuxleySquidAxonModel1952CodeGenerationTests(TrackingType::COMPUTED_CONSTANTS, + {}, {}, {}, + {"Variable 'E_K' in component 'potassium_channel' is needed to compute an external variable and cannot therefore be untracked."}, + {libcellml::Issue::Level::ERROR}, + {libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE}); } -const std::vector algebraicRelatedExternalIssues = { - "Variable 'alpha_m' in component 'sodium_channel_m_gate' is needed to compute an external variable and cannot therefore be untracked.", -}; - TEST(GeneratorVariableTracker, hodgkinHuxleySquidAxonModel1952UntrackedAlgebraicVariables) { - hodgkinHuxleySquidAxonModel1952CodeGeneration(true, TrackingType::ALGEBRAIC, - {}, {}, {}, - {"Variable 'alpha_m' in component 'sodium_channel_m_gate' is needed to compute an external variable and cannot therefore be untracked."}, - {libcellml::Issue::Level::ERROR}, - {libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE}); + hodgkinHuxleySquidAxonModel1952CodeGenerationTests(TrackingType::ALGEBRAIC_VARIABLES, + {}, {}, {}, + {"Variable 'alpha_m' in component 'sodium_channel_m_gate' is needed to compute an external variable and cannot therefore be untracked."}, + {libcellml::Issue::Level::ERROR}, + {libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE}); } TEST(GeneratorVariableTracker, hodgkinHuxleySquidAxonModel1952UntrackedVariables) { - hodgkinHuxleySquidAxonModel1952CodeGeneration(true, TrackingType::VARIABLES, - {}, {}, {}, - { - "Variable 'Cm' in component 'membrane' is needed to compute an external variable and cannot therefore be untracked.", - "Variable 'E_K' in component 'potassium_channel' is needed to compute an external variable and cannot therefore be untracked.", - "Variable 'alpha_m' in component 'sodium_channel_m_gate' is needed to compute an external variable and cannot therefore be untracked.", - }, - expectedLevels(3, libcellml::Issue::Level::ERROR), - expectedReferenceRules(3, libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE)); -} - -TEST(GeneratorVariableTracker, hodgkinHuxleySquidAxonModel1952DaeControl) -{ - hodgkinHuxleySquidAxonModel1952CodeGeneration(false, TrackingType::CONTROL, - {}, {}, {}, - {}, {}, {}); -} - -TEST(GeneratorVariableTracker, hodgkinHuxleySquidAxonModel1952DaeUntrackedConstants) -{ - hodgkinHuxleySquidAxonModel1952CodeGeneration(false, TrackingType::CONSTANTS, - {}, {}, {}, - {"Variable 'Cm' in component 'membrane' is needed to compute an external variable and cannot therefore be untracked."}, - {libcellml::Issue::Level::ERROR}, - {libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE}); -} - -TEST(GeneratorVariableTracker, hodgkinHuxleySquidAxonModel1952DaeUntrackedComputedConstants) -{ - hodgkinHuxleySquidAxonModel1952CodeGeneration(false, TrackingType::COMPUTED_CONSTANTS, - {}, {}, {}, - {"Variable 'E_K' in component 'potassium_channel' is needed to compute an external variable and cannot therefore be untracked."}, - {libcellml::Issue::Level::ERROR}, - {libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE}); -} - -const std::vector daeIssues = { - "Variable 'i_Stim' in component 'membrane' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'i_L' in component 'leakage_current' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'i_K' in component 'potassium_channel' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'i_Na' in component 'sodium_channel' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'E_L' in component 'leakage_current' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'E_Na' in component 'sodium_channel' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'beta_m' in component 'sodium_channel_m_gate' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'alpha_h' in component 'sodium_channel_h_gate' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'beta_h' in component 'sodium_channel_h_gate' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'alpha_n' in component 'potassium_channel_n_gate' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'beta_n' in component 'potassium_channel_n_gate' is computed using an NLA system and cannot therefore be untracked.", -}; -const std::vector daeLevels = expectedLevels(daeIssues.size(), libcellml::Issue::Level::ERROR); -const std::vector daeReferenceRules = expectedReferenceRules(daeIssues.size(), libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE); - -TEST(GeneratorVariableTracker, hodgkinHuxleySquidAxonModel1952DaeUntrackedAlgebraicVariables) -{ - const std::vector daeExternalIssues = { - "Variable 'i_Stim' in component 'membrane' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'i_L' in component 'leakage_current' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'i_K' in component 'potassium_channel' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'E_L' in component 'leakage_current' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'E_Na' in component 'sodium_channel' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'alpha_m' in component 'sodium_channel_m_gate' is needed to compute an external variable and cannot therefore be untracked.", - "Variable 'beta_m' in component 'sodium_channel_m_gate' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'alpha_h' in component 'sodium_channel_h_gate' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'beta_h' in component 'sodium_channel_h_gate' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'alpha_n' in component 'potassium_channel_n_gate' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'beta_n' in component 'potassium_channel_n_gate' is computed using an NLA system and cannot therefore be untracked.", - }; - const std::vector daeExternalReferenceRules = { - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - }; - - hodgkinHuxleySquidAxonModel1952CodeGeneration(false, TrackingType::ALGEBRAIC, - daeIssues, daeLevels, daeReferenceRules, - daeExternalIssues, expectedLevels(daeExternalIssues.size(), libcellml::Issue::Level::ERROR), daeExternalReferenceRules); -} - -TEST(GeneratorVariableTracker, hodgkinHuxleySquidAxonModel1952DaeUntrackedVariables) -{ - const std::vector daeExternalIssues = { - "Variable 'Cm' in component 'membrane' is needed to compute an external variable and cannot therefore be untracked.", - "Variable 'E_K' in component 'potassium_channel' is needed to compute an external variable and cannot therefore be untracked.", - "Variable 'i_Stim' in component 'membrane' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'i_L' in component 'leakage_current' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'i_K' in component 'potassium_channel' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'E_L' in component 'leakage_current' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'E_Na' in component 'sodium_channel' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'alpha_m' in component 'sodium_channel_m_gate' is needed to compute an external variable and cannot therefore be untracked.", - "Variable 'beta_m' in component 'sodium_channel_m_gate' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'alpha_h' in component 'sodium_channel_h_gate' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'beta_h' in component 'sodium_channel_h_gate' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'alpha_n' in component 'potassium_channel_n_gate' is computed using an NLA system and cannot therefore be untracked.", - "Variable 'beta_n' in component 'potassium_channel_n_gate' is computed using an NLA system and cannot therefore be untracked.", - }; - const std::vector daeExternalReferenceRules = { - libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, - }; - - hodgkinHuxleySquidAxonModel1952CodeGeneration(false, TrackingType::VARIABLES, - daeIssues, daeLevels, daeReferenceRules, - daeExternalIssues, expectedLevels(daeExternalIssues.size(), libcellml::Issue::Level::ERROR), daeExternalReferenceRules); + hodgkinHuxleySquidAxonModel1952CodeGenerationTests(TrackingType::VARIABLES, + {}, {}, {}, + { + "Variable 'Cm' in component 'membrane' is needed to compute an external variable and cannot therefore be untracked.", + "Variable 'E_K' in component 'potassium_channel' is needed to compute an external variable and cannot therefore be untracked.", + "Variable 'alpha_m' in component 'sodium_channel_m_gate' is needed to compute an external variable and cannot therefore be untracked.", + }, + expectedLevels(3, libcellml::Issue::Level::ERROR), + expectedReferenceRules(3, libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE)); } diff --git a/tests/printer/printer.cpp b/tests/printer/printer.cpp index 74692e53d3..5b30d99da2 100644 --- a/tests/printer/printer.cpp +++ b/tests/printer/printer.cpp @@ -1038,3 +1038,52 @@ TEST(Printer, printComponentWithMultipleFullyQualifiedMathDocuments) const std::string e = fileContents("printer/component_with_multiple_math.cellml"); EXPECT_EQ(e, printer->printModel(model)); } + +TEST(Printer, printComponentWithXmlStylesheetProcessingInstructionInMath) +{ + auto printer = libcellml::Printer::create(); + auto model = libcellml::Model::create("model"); + auto component = libcellml::Component::create("environment"); + const std::string math = + "\n" + "\n" + " \n" + " \n" + " x\n" + " 1\n" + " \n" + "\n"; + + model->addComponent(component); + component->setMath(math); + + auto output = printer->printModel(model); + + EXPECT_EQ(size_t(0), printer->issueCount()); + EXPECT_NE(std::string::npos, output.find("x")); +} + +TEST(Printer, printComponentWithMalformedXmlDeclarationInMath) +{ + auto printer = libcellml::Printer::create(); + auto model = libcellml::Model::create("model"); + auto component = libcellml::Component::create("environment"); + const std::string math = + "\n" + " \n" + " \n" + " x\n" + " 1\n" + " \n" + "\n"; + + model->addComponent(component); + component->setMath(math); + + auto output = printer->printModel(model); + + EXPECT_GT(printer->issueCount(), size_t(0)); + EXPECT_EQ(std::string::npos, output.find(" - diff --git a/tests/resources/analyser/overconstrained_nla_system.cellml b/tests/resources/analyser/overconstrained_nla_system.cellml index 1c76da7dca..0eb2e64050 100644 --- a/tests/resources/analyser/overconstrained_nla_system.cellml +++ b/tests/resources/analyser/overconstrained_nla_system.cellml @@ -1,17 +1,17 @@ - - - + + + diff --git a/tests/resources/analyser/symengine/addition.cellml b/tests/resources/analyser/symengine/addition.cellml new file mode 100644 index 0000000000..f78f859924 --- /dev/null +++ b/tests/resources/analyser/symengine/addition.cellml @@ -0,0 +1,56 @@ + + + + + + + + + + + + + + + + + + + + + awx + 10 + + + + + + + by2 + 1 + + + + + + + cx1 + z + + + + + + + dw + y + + + + w2 + x3 + y4 + z5 + + + diff --git a/tests/resources/analyser/symengine/arithmetic_simplifications.c b/tests/resources/analyser/symengine/arithmetic_simplifications.c new file mode 100644 index 0000000000..efde995bbf --- /dev/null +++ b/tests/resources/analyser/symengine/arithmetic_simplifications.c @@ -0,0 +1,236 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t CONSTANT_COUNT = 1; +const size_t COMPUTED_CONSTANT_COUNT = 76; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; + +const VariableInfo CONSTANT_INFO[] = { + {"a", "dimensionless", "my_component"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"plusEqn1", "dimensionless", "my_component"}, + {"plusEqn2", "dimensionless", "my_component"}, + {"plusEqn3", "dimensionless", "my_component"}, + {"plusEqn4", "dimensionless", "my_component"}, + {"plusEqn5", "dimensionless", "my_component"}, + {"plusEqn6", "dimensionless", "my_component"}, + {"plusEqn7", "dimensionless", "my_component"}, + {"minusEqn1", "dimensionless", "my_component"}, + {"minusEqn2", "dimensionless", "my_component"}, + {"minusEqn3", "dimensionless", "my_component"}, + {"minusEqn4", "dimensionless", "my_component"}, + {"minusEqn5", "dimensionless", "my_component"}, + {"minusEqn6", "dimensionless", "my_component"}, + {"minusEqn7", "dimensionless", "my_component"}, + {"minusEqn8", "dimensionless", "my_component"}, + {"minusEqn9", "dimensionless", "my_component"}, + {"minusEqn10", "dimensionless", "my_component"}, + {"minusEqn11", "dimensionless", "my_component"}, + {"minusEqn12", "dimensionless", "my_component"}, + {"minusEqn13", "dimensionless", "my_component"}, + {"minusEqn14", "dimensionless", "my_component"}, + {"timesEqn1", "dimensionless", "my_component"}, + {"timesEqn2", "dimensionless", "my_component"}, + {"timesEqn3", "dimensionless", "my_component"}, + {"timesEqn4", "dimensionless", "my_component"}, + {"timesEqn5", "dimensionless", "my_component"}, + {"timesEqn6", "dimensionless", "my_component"}, + {"timesEqn7", "dimensionless", "my_component"}, + {"timesEqn8", "dimensionless", "my_component"}, + {"timesEqn9", "dimensionless", "my_component"}, + {"timesEqn10", "dimensionless", "my_component"}, + {"divideEqn1", "dimensionless", "my_component"}, + {"divideEqn2", "dimensionless", "my_component"}, + {"divideEqn3", "dimensionless", "my_component"}, + {"divideEqn4", "dimensionless", "my_component"}, + {"divideEqn5", "dimensionless", "my_component"}, + {"divideEqn6", "dimensionless", "my_component"}, + {"divideEqn7", "dimensionless", "my_component"}, + {"divideEqn8", "dimensionless", "my_component"}, + {"powerEqn1", "dimensionless", "my_component"}, + {"powerEqn2", "dimensionless", "my_component"}, + {"powerEqn3", "dimensionless", "my_component"}, + {"powerEqn4", "dimensionless", "my_component"}, + {"powerEqn5", "dimensionless", "my_component"}, + {"powerEqn6", "dimensionless", "my_component"}, + {"powerEqn7", "dimensionless", "my_component"}, + {"rootEqn1", "dimensionless", "my_component"}, + {"rootEqn2", "dimensionless", "my_component"}, + {"rootEqn3", "dimensionless", "my_component"}, + {"rootEqn4", "dimensionless", "my_component"}, + {"rootEqn5", "dimensionless", "my_component"}, + {"rootEqn6", "dimensionless", "my_component"}, + {"absEqn1", "dimensionless", "my_component"}, + {"expEqn1", "dimensionless", "my_component"}, + {"lnEqn1", "dimensionless", "my_component"}, + {"logEqn1", "dimensionless", "my_component"}, + {"logEqn2", "dimensionless", "my_component"}, + {"logEqn3", "dimensionless", "my_component"}, + {"logEqn4", "dimensionless", "my_component"}, + {"logEqn5", "dimensionless", "my_component"}, + {"ceilingEqn1", "dimensionless", "my_component"}, + {"ceilingEqn2", "dimensionless", "my_component"}, + {"floorEqn1", "dimensionless", "my_component"}, + {"floorEqn2", "dimensionless", "my_component"}, + {"minEqn1", "dimensionless", "my_component"}, + {"minEqn2", "dimensionless", "my_component"}, + {"minEqn3", "dimensionless", "my_component"}, + {"minEqn4", "dimensionless", "my_component"}, + {"maxEqn1", "dimensionless", "my_component"}, + {"maxEqn2", "dimensionless", "my_component"}, + {"maxEqn3", "dimensionless", "my_component"}, + {"maxEqn4", "dimensionless", "my_component"}, + {"remEqn1", "dimensionless", "my_component"}, + {"remEqn2", "dimensionless", "my_component"}, + {"remEqn3", "dimensionless", "my_component"}, + {"remEqn4", "dimensionless", "my_component"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { +}; + +double min(double x, double y) +{ + return (x < y)?x:y; +} + +double max(double x, double y) +{ + return (x > y)?x:y; +} + +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 *constants, double *computedConstants, double *algebraicVariables) +{ + constants[0] = 1.0; + computedConstants[3] = 2.0; + computedConstants[10] = 0.0; + computedConstants[13] = -1.0; + computedConstants[24] = 1.0; + computedConstants[25] = 0.0; + computedConstants[26] = 0.0; + computedConstants[34] = 1.0; + computedConstants[35] = 0.0; + computedConstants[40] = 1.0; + computedConstants[42] = 1.0; + computedConstants[43] = 1.0; + computedConstants[44] = 0.0; + computedConstants[49] = 1.0; + computedConstants[51] = 1.0; + computedConstants[52] = 1.0; + computedConstants[53] = 2.71828182845905; + computedConstants[54] = 1.00000000001507; + computedConstants[58] = 1.0; + computedConstants[59] = 1.0; + computedConstants[61] = 2.0; + computedConstants[63] = 1.0; + computedConstants[67] = 1.0; + computedConstants[71] = 1.0; + computedConstants[75] = 0.0; +} + +void computeComputedConstants(double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[0]+constants[0]; + computedConstants[1] = 1.0+constants[0]; + computedConstants[2] = constants[0]+1.0; + computedConstants[4] = constants[0]; + computedConstants[5] = constants[0]; + computedConstants[6] = constants[0]; + computedConstants[7] = constants[0]-constants[0]; + computedConstants[8] = 1.0-constants[0]; + computedConstants[9] = constants[0]-1.0; + computedConstants[11] = -constants[0]; + computedConstants[12] = constants[0]; + computedConstants[14] = constants[0]; + computedConstants[15] = -constants[0]-constants[0]; + computedConstants[16] = -constants[0]+constants[0]; + computedConstants[17] = (-constants[0]-constants[0])*constants[0]; + computedConstants[18] = (-constants[0]+constants[0])*constants[0]; + computedConstants[19] = (-constants[0]-constants[0])/constants[0]; + computedConstants[20] = (-constants[0]+constants[0])/constants[0]; + computedConstants[21] = constants[0]*constants[0]; + computedConstants[22] = constants[0]; + computedConstants[23] = constants[0]; + computedConstants[27] = -constants[0]; + computedConstants[28] = -constants[0]; + computedConstants[29] = constants[0]/constants[0]; + computedConstants[30] = constants[0]/constants[0]; + computedConstants[31] = constants[0]/constants[0]; + computedConstants[32] = 1.0/constants[0]; + computedConstants[33] = constants[0]; + computedConstants[36] = -constants[0]; + computedConstants[37] = constants[0]; + computedConstants[38] = 1.0/(2.0/constants[0]); + computedConstants[39] = pow(constants[0], constants[0]); + computedConstants[41] = constants[0]; + computedConstants[45] = 1.0/constants[0]; + computedConstants[46] = pow(constants[0], 1.0/constants[0]); + computedConstants[47] = pow(1.0, 1.0/constants[0]); + computedConstants[48] = pow(constants[0], 1.0/1.0); + computedConstants[50] = sqrt(constants[0]); + computedConstants[55] = log(constants[0])/log(constants[0]); + computedConstants[56] = log(constants[0])/log(1.0); + computedConstants[57] = log(1.0)/log(constants[0]); + computedConstants[60] = ceil(constants[0]); + computedConstants[62] = floor(constants[0]); + computedConstants[64] = min(constants[0], constants[0]); + computedConstants[65] = min(1.0, constants[0]); + computedConstants[66] = min(constants[0], 1.0); + computedConstants[68] = max(constants[0], constants[0]); + computedConstants[69] = max(1.0, constants[0]); + computedConstants[70] = max(constants[0], 1.0); + computedConstants[72] = fmod(constants[0], constants[0]); + computedConstants[73] = fmod(1.0, constants[0]); + computedConstants[74] = fmod(constants[0], 1.0); +} + +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/analyser/symengine/arithmetic_simplifications.cellml b/tests/resources/analyser/symengine/arithmetic_simplifications.cellml new file mode 100644 index 0000000000..20636d2848 --- /dev/null +++ b/tests/resources/analyser/symengine/arithmetic_simplifications.cellml @@ -0,0 +1,249 @@ + + + + + + + + + + + + + + + + + + plusEqn1aa + plusEqn21a + plusEqn3a1 + plusEqn411 + plusEqn50a + plusEqn6a0 + plusEqn7a + + + + + + + + + + + + + + + + + + + + + minusEqn1aa + minusEqn21a + minusEqn3a1 + minusEqn411 + minusEqn50a + minusEqn6a0 + minusEqn71 + minusEqn8a + minusEqn9aa + minusEqn10aa + minusEqn11aaa + minusEqn12aaa + minusEqn13aaa + minusEqn14aaa + + + + + + + + + + + + + + + + + timesEqn1aa + timesEqn21a + timesEqn3a1 + timesEqn411 + timesEqn50a + timesEqn6a0 + timesEqn7-1a + timesEqn8a-1 + timesEqn91aa + timesEqn10a1a + + + + + + + + + + + + + + + divideEqn1aa + divideEqn21a + divideEqn3a1 + divideEqn411 + divideEqn50a + divideEqn6a-1 + divideEqn711a + divideEqn812a + + + + + + + + + + + + + + powerEqn1aa + powerEqn21a + powerEqn3a1 + powerEqn411 + powerEqn5a0 + powerEqn60a + powerEqn7a-1 + + + + + + + + + + + + + rootEqn1aa + rootEqn2a1 + rootEqn31a + rootEqn411 + rootEqn5a + rootEqn61 + + + + + + + + absEqn1-1 + + + + + + + + expEqn11 + + + + + + + + lnEqn12.7182818285 + + + + + + + + + + + + logEqn1aa + logEqn21a + logEqn3a1 + logEqn421 + logEqn510 + + + + + + + + + ceilingEqn1a + ceilingEqn21.5 + + + + + + + + + floorEqn1a + floorEqn21.5 + + + + + + + + + + + minEqn1aa + minEqn21a + minEqn3a1 + minEqn411 + + + + + + + + + + + maxEqn1aa + maxEqn21a + maxEqn3a1 + maxEqn411 + + + + + + + + + + + remEqn1aa + remEqn21a + remEqn3a1 + remEqn411 + + + diff --git a/tests/resources/analyser/symengine/capillary_network/capillary_network.cellml b/tests/resources/analyser/symengine/capillary_network/capillary_network.cellml new file mode 100644 index 0000000000..c4cac344d9 --- /dev/null +++ b/tests/resources/analyser/symengine/capillary_network/capillary_network.cellml @@ -0,0 +1,461 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/resources/analyser/symengine/capillary_network/capillary_network_modules.cellml b/tests/resources/analyser/symengine/capillary_network/capillary_network_modules.cellml new file mode 100644 index 0000000000..d0faca37e9 --- /dev/null +++ b/tests/resources/analyser/symengine/capillary_network/capillary_network_modules.cellml @@ -0,0 +1,769 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + h + + + r + + + + + a_vessel + + + + + b_vessel + r + + + + + + c_vessel + + + + + d_vessel + r + + + + + + + + + I + + + + + rho + l + + + + + + + r + 2 + + + + + + + C + + + + + 2 + + + + r + 3 + + l + + + + E + h + + + + + + R + + + + + 8 + mu + l + + + + + + + r + 4 + + + + + + + R_v + + + 0.01 + C + + + + + + + + + t + + v + + + + + + + + + + u + u_d + + + + R + v + + + + + beta_g + rho + g + l + + + + + + + theta + + + 180 + + + + + I + + + + + + + + t + + q_C + + + + v_in + v + + + + + u_C + + + + + q_C + + + C + 2 + + + u_ext + + + + + + + + t + + q_C_d + + + + + + v + v_out_1 + + v_out_2 + + + + + u_C_d + + + + + q_C_d + + + C + 2 + + + u_ext + + + + + u + + + u_C + + + 2 + R_v + + + v_in + v + + + + + + + + u_d + + + u_C_d + + + 2 + R_v + + + + + v + v_out_1 + + v_out_2 + + + + + + + + + + + + + + v_zero + 0 + + + + + + + + + + + + + + + + + + + + v + + + + + u_in + u + + R + + + + + + + + t + + q_C + + + + v + v_out + + + + + + u + + + + + q_C + C + + u_ext + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + h + + + r + + + + + a_vessel + + + + + b_vessel + r + + + + + + c_vessel + + + + + d_vessel + r + + + + + + + + + I + + + + + rho + l + + + + + + + r + 2 + + + + + + + C + + + + + 2 + + + + r + 3 + + l + + + + E + h + + + + + + R + + + + + 8 + mu + l + + + + + + + r + 4 + + + + + + + + + + + t + + v + + + + + + + + u_in + u + + + + R + v + + + I + + + + + + v_out_total + + + v_out_1 + v_out_2 + + + + + + + + t + + q_C + + + + v + v_out_total + + + + + u + + + + + q_C + C + + u_ext + + + + + diff --git a/tests/resources/analyser/symengine/capillary_network/capillary_network_parameters.cellml b/tests/resources/analyser/symengine/capillary_network/capillary_network_parameters.cellml new file mode 100644 index 0000000000..73c1a068f9 --- /dev/null +++ b/tests/resources/analyser/symengine/capillary_network/capillary_network_parameters.cellml @@ -0,0 +1,235 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/resources/analyser/symengine/capillary_network/capillary_network_units.cellml b/tests/resources/analyser/symengine/capillary_network/capillary_network_units.cellml new file mode 100644 index 0000000000..e2d429c2ba --- /dev/null +++ b/tests/resources/analyser/symengine/capillary_network/capillary_network_units.cellml @@ -0,0 +1,812 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/resources/analyser/symengine/constants.cellml b/tests/resources/analyser/symengine/constants.cellml new file mode 100644 index 0000000000..3590778dc7 --- /dev/null +++ b/tests/resources/analyser/symengine/constants.cellml @@ -0,0 +1,67 @@ + + + + + + + + + + + + + + + + + + + + + + + + ax + 8.65 + + + + + + + bw + 45 + + + + + + + cy + + + + + + + + dz + + + + + + + + ew + + + + + w3 + x4 + y5 + z2 + + + diff --git a/tests/resources/analyser/symengine/coverage.cellml b/tests/resources/analyser/symengine/coverage.cellml new file mode 100644 index 0000000000..3ac602c963 --- /dev/null +++ b/tests/resources/analyser/symengine/coverage.cellml @@ -0,0 +1,321 @@ + + + + + + + + + + x0 + ab + + + + + + + + + + + ab + y1 + + + + + + + + + + x0 + a2.5 + + + + + + + + + + x0 + + + 2 + 10.5 + + 0 + + + + + bx + 1 + + + + + + + + + + + + + + + + y10 + ab + + + + y20 + ab + + + + y30 + ab + + + + y40 + + + a0 + b0 + + + + + y50 + + + a0 + b0 + + + + + y60 + + + a0 + b0 + + + + + + + + + + + + + + x + + + + x + y + + + + + + + + + + + + + x0 + + + + + ab + bc + + + + + + + + + + + + + y0 + + + ab + a0 + + + + + + + + + + + + + + 2w + e5 + + + + y3 + z5 + + + + 1g + w + + w3 + y2 + + + + + + + + + + a + 1000000000000000000 + + 0 + + + + + + + + + + + + a + x + + 0 + + + + x + 2 + + + + + + + + + + + 2 + 10 + + 0 + + x + + + + + + + + + + + tx + 1 + + + + yyt + 1 + + + + + + + + + + + + + + + + x + z + w + + 0 + + + + + + x + z + w + + 1 + + + + + + x + v + u + + 2 + + + + + + v + y + + 3 + + + + + + y + w + u + + 4 + + + + diff --git a/tests/resources/analyser/symengine/coverage_linux.c b/tests/resources/analyser/symengine/coverage_linux.c new file mode 100644 index 0000000000..2e309b497b --- /dev/null +++ b/tests/resources/analyser/symengine/coverage_linux.c @@ -0,0 +1,253 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 1; +const size_t CONSTANT_COUNT = 15; +const size_t COMPUTED_CONSTANT_COUNT = 26; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "nla_with_variable_of_integration"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "nla_with_variable_of_integration"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"b", "dimensionless", "not_greater_than_rearrangement"}, + {"a", "dimensionless", "not_greater_than_rearrangement"}, + {"b", "dimensionless", "opaque_logical_equation"}, + {"a", "dimensionless", "opaque_logical_equation"}, + {"a", "dimensionless", "non_integer_power_rearrangement"}, + {"b", "dimensionless", "boolean_rearrangement"}, + {"a", "dimensionless", "boolean_rearrangement"}, + {"y", "dimensionless", "nan_rearrangement"}, + {"c", "dimensionless", "not_xor_rearrangement"}, + {"b", "dimensionless", "not_xor_rearrangement"}, + {"a", "dimensionless", "not_xor_rearrangement"}, + {"a", "dimensionless", "nested_equality_convert_to_eq_type"}, + {"b", "dimensionless", "nested_equality_convert_to_eq_type"}, + {"u", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"}, + {"v", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"x", "dimensionless", "not_greater_than_rearrangement"}, + {"x", "dimensionless", "non_integer_power_rearrangement"}, + {"x", "dimensionless", "piecewise_substitution"}, + {"b", "dimensionless", "piecewise_substitution"}, + {"y1", "dimensionless", "boolean_rearrangement"}, + {"y2", "dimensionless", "boolean_rearrangement"}, + {"y3", "dimensionless", "boolean_rearrangement"}, + {"y4", "dimensionless", "boolean_rearrangement"}, + {"y5", "dimensionless", "boolean_rearrangement"}, + {"y6", "dimensionless", "boolean_rearrangement"}, + {"x", "dimensionless", "nan_rearrangement"}, + {"x", "dimensionless", "not_xor_rearrangement"}, + {"y", "dimensionless", "nested_equality_convert_to_eq_type"}, + {"e", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"w", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"z", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"y", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"g", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"a", "dimensionless", "scientific_notation"}, + {"x", "dimensionless", "power_with_pi_base"}, + {"a", "dimensionless", "power_with_pi_base"}, + {"x", "dimensionless", "swap_rhs_variable_piecewise"}, + {"w", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"}, + {"z", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"}, + {"x", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"}, + {"y", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y", "dimensionless", "opaque_logical_equation"}, + {"y", "dimensionless", "nla_with_variable_of_integration"} +}; + +double xor(double x, double y) +{ + return (x != 0.0) ^ (y != 0.0); +} + +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] = (constants[3] && constants[2])-(algebraicVariables[0]+1.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] = sin(algebraicVariables[1])+voi+algebraicVariables[1]-1.0; +} + +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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + constants[0] = 3.0; + constants[1] = 1.0; + constants[2] = 1.0; + constants[3] = 0.0; + constants[4] = 4.0; + constants[5] = 2.0; + constants[6] = 1.0; + constants[7] = 1.0; + constants[8] = 3.0; + constants[9] = 2.0; + constants[10] = 1.0; + constants[11] = 1.0; + constants[12] = 1.0; + constants[13] = 1.0; + constants[14] = 2.0; + computedConstants[2] = (1.0)?2.0:0.0; + computedConstants[3] = 1.0+((1.0)?2.0:0.0); + computedConstants[14] = 3.0; + computedConstants[16] = 2.0; + computedConstants[18] = -1.0e+18; + computedConstants[19] = 2.0; + computedConstants[21] = (1.0)?2.0:0.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[1] <= constants[0]; + computedConstants[1] = pow(constants[4], 2.5); + computedConstants[4] = constants[6] != constants[5]; + computedConstants[5] = constants[6] < constants[5]; + computedConstants[6] = constants[6] <= constants[5]; + computedConstants[7] = (0.0 < constants[6]) && (0.0 < constants[5]); + computedConstants[8] = (0.0 < constants[6]) || (0.0 < constants[5]); + computedConstants[9] = xor(0.0 < constants[6], 0.0 < constants[5]); + computedConstants[10] = constants[7]/(-1.0+NAN); + computedConstants[11] = !xor(constants[9] < constants[8], constants[9] < constants[10]); + computedConstants[12] = (0.0 < constants[11]) && (constants[11] == constants[12]); + computedConstants[13] = -5.0+pow(2.0, computedConstants[14]); + computedConstants[15] = -5.0+pow(computedConstants[16], 3.0); + computedConstants[17] = 1.0/computedConstants[14]; + computedConstants[20] = -pow(3.14159265358979, computedConstants[19]); + computedConstants[25] = 3.0-constants[14]; + computedConstants[22] = 4.0-computedConstants[25]-constants[13]; + computedConstants[24] = 2.0-constants[13]-constants[14]; + computedConstants[23] = -computedConstants[24]-computedConstants[22]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[0] = 1.0; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); +} diff --git a/tests/resources/analyser/symengine/coverage_macos.c b/tests/resources/analyser/symengine/coverage_macos.c new file mode 100644 index 0000000000..4e0bbd38cc --- /dev/null +++ b/tests/resources/analyser/symengine/coverage_macos.c @@ -0,0 +1,253 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 1; +const size_t CONSTANT_COUNT = 15; +const size_t COMPUTED_CONSTANT_COUNT = 26; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "nla_with_variable_of_integration"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "nla_with_variable_of_integration"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"b", "dimensionless", "not_greater_than_rearrangement"}, + {"a", "dimensionless", "not_greater_than_rearrangement"}, + {"b", "dimensionless", "opaque_logical_equation"}, + {"a", "dimensionless", "opaque_logical_equation"}, + {"a", "dimensionless", "non_integer_power_rearrangement"}, + {"b", "dimensionless", "boolean_rearrangement"}, + {"a", "dimensionless", "boolean_rearrangement"}, + {"y", "dimensionless", "nan_rearrangement"}, + {"c", "dimensionless", "not_xor_rearrangement"}, + {"b", "dimensionless", "not_xor_rearrangement"}, + {"a", "dimensionless", "not_xor_rearrangement"}, + {"a", "dimensionless", "nested_equality_convert_to_eq_type"}, + {"b", "dimensionless", "nested_equality_convert_to_eq_type"}, + {"u", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"}, + {"v", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"x", "dimensionless", "not_greater_than_rearrangement"}, + {"x", "dimensionless", "non_integer_power_rearrangement"}, + {"x", "dimensionless", "piecewise_substitution"}, + {"b", "dimensionless", "piecewise_substitution"}, + {"y1", "dimensionless", "boolean_rearrangement"}, + {"y2", "dimensionless", "boolean_rearrangement"}, + {"y3", "dimensionless", "boolean_rearrangement"}, + {"y4", "dimensionless", "boolean_rearrangement"}, + {"y5", "dimensionless", "boolean_rearrangement"}, + {"y6", "dimensionless", "boolean_rearrangement"}, + {"x", "dimensionless", "nan_rearrangement"}, + {"x", "dimensionless", "not_xor_rearrangement"}, + {"y", "dimensionless", "nested_equality_convert_to_eq_type"}, + {"e", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"w", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"z", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"y", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"g", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"a", "dimensionless", "scientific_notation"}, + {"x", "dimensionless", "power_with_pi_base"}, + {"a", "dimensionless", "power_with_pi_base"}, + {"x", "dimensionless", "swap_rhs_variable_piecewise"}, + {"w", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"}, + {"z", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"}, + {"x", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"}, + {"y", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y", "dimensionless", "opaque_logical_equation"}, + {"y", "dimensionless", "nla_with_variable_of_integration"} +}; + +double xor(double x, double y) +{ + return (x != 0.0) ^ (y != 0.0); +} + +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] = (constants[3] && constants[2])-(algebraicVariables[0]+1.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] = sin(algebraicVariables[1])+voi+algebraicVariables[1]-1.0; +} + +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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + constants[0] = 3.0; + constants[1] = 1.0; + constants[2] = 1.0; + constants[3] = 0.0; + constants[4] = 4.0; + constants[5] = 2.0; + constants[6] = 1.0; + constants[7] = 1.0; + constants[8] = 3.0; + constants[9] = 2.0; + constants[10] = 1.0; + constants[11] = 1.0; + constants[12] = 1.0; + constants[13] = 1.0; + constants[14] = 2.0; + computedConstants[2] = (1.0)?2.0:0.0; + computedConstants[3] = 1.0+((1.0)?2.0:0.0); + computedConstants[14] = 3.0; + computedConstants[16] = 2.0; + computedConstants[18] = -1.0e+18; + computedConstants[19] = 2.0; + computedConstants[21] = (1.0)?2.0:0.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[1] <= constants[0]; + computedConstants[1] = pow(constants[4], 2.5); + computedConstants[4] = constants[6] != constants[5]; + computedConstants[5] = constants[6] < constants[5]; + computedConstants[6] = constants[6] <= constants[5]; + computedConstants[7] = (0.0 < constants[6]) && (0.0 < constants[5]); + computedConstants[8] = (0.0 < constants[6]) || (0.0 < constants[5]); + computedConstants[9] = xor(0.0 < constants[6], 0.0 < constants[5]); + computedConstants[10] = constants[7]/(-1.0+NAN); + computedConstants[11] = !xor(constants[9] < constants[8], constants[9] < constants[10]); + computedConstants[12] = (0.0 < constants[11]) && (constants[11] == constants[12]); + computedConstants[13] = -5.0+pow(2.0, computedConstants[14]); + computedConstants[15] = -5.0+pow(computedConstants[16], 3.0); + computedConstants[17] = 1.0/computedConstants[14]; + computedConstants[20] = -pow(3.14159265358979, computedConstants[19]); + computedConstants[25] = 3.0-constants[14]; + computedConstants[22] = 4.0-computedConstants[25]-constants[13]; + computedConstants[24] = 2.0-constants[14]-constants[13]; + computedConstants[23] = -computedConstants[24]-computedConstants[22]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[0] = 1.0; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); +} diff --git a/tests/resources/analyser/symengine/coverage_windows.c b/tests/resources/analyser/symengine/coverage_windows.c new file mode 100644 index 0000000000..2b092516ed --- /dev/null +++ b/tests/resources/analyser/symengine/coverage_windows.c @@ -0,0 +1,253 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 1; +const size_t CONSTANT_COUNT = 15; +const size_t COMPUTED_CONSTANT_COUNT = 26; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "nla_with_variable_of_integration"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "nla_with_variable_of_integration"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"b", "dimensionless", "not_greater_than_rearrangement"}, + {"a", "dimensionless", "not_greater_than_rearrangement"}, + {"b", "dimensionless", "opaque_logical_equation"}, + {"a", "dimensionless", "opaque_logical_equation"}, + {"a", "dimensionless", "non_integer_power_rearrangement"}, + {"b", "dimensionless", "boolean_rearrangement"}, + {"a", "dimensionless", "boolean_rearrangement"}, + {"y", "dimensionless", "nan_rearrangement"}, + {"c", "dimensionless", "not_xor_rearrangement"}, + {"b", "dimensionless", "not_xor_rearrangement"}, + {"a", "dimensionless", "not_xor_rearrangement"}, + {"a", "dimensionless", "nested_equality_convert_to_eq_type"}, + {"b", "dimensionless", "nested_equality_convert_to_eq_type"}, + {"u", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"}, + {"v", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"x", "dimensionless", "not_greater_than_rearrangement"}, + {"x", "dimensionless", "non_integer_power_rearrangement"}, + {"x", "dimensionless", "piecewise_substitution"}, + {"b", "dimensionless", "piecewise_substitution"}, + {"y1", "dimensionless", "boolean_rearrangement"}, + {"y2", "dimensionless", "boolean_rearrangement"}, + {"y3", "dimensionless", "boolean_rearrangement"}, + {"y4", "dimensionless", "boolean_rearrangement"}, + {"y5", "dimensionless", "boolean_rearrangement"}, + {"y6", "dimensionless", "boolean_rearrangement"}, + {"x", "dimensionless", "nan_rearrangement"}, + {"x", "dimensionless", "not_xor_rearrangement"}, + {"y", "dimensionless", "nested_equality_convert_to_eq_type"}, + {"e", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"w", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"z", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"y", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"g", "dimensionless", "invert_simple_odd_power_edge_cases"}, + {"a", "dimensionless", "scientific_notation"}, + {"x", "dimensionless", "power_with_pi_base"}, + {"a", "dimensionless", "power_with_pi_base"}, + {"x", "dimensionless", "swap_rhs_variable_piecewise"}, + {"w", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"}, + {"z", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"}, + {"x", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"}, + {"y", "dimensionless", "tearing_variable_tiebreaker_uses_match_making"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y", "dimensionless", "opaque_logical_equation"}, + {"y", "dimensionless", "nla_with_variable_of_integration"} +}; + +double xor(double x, double y) +{ + return (x != 0.0) ^ (y != 0.0); +} + +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] = (constants[3] && constants[2])-(algebraicVariables[0]+1.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] = algebraicVariables[1]+voi+sin(algebraicVariables[1])-1.0; +} + +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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + constants[0] = 3.0; + constants[1] = 1.0; + constants[2] = 1.0; + constants[3] = 0.0; + constants[4] = 4.0; + constants[5] = 2.0; + constants[6] = 1.0; + constants[7] = 1.0; + constants[8] = 3.0; + constants[9] = 2.0; + constants[10] = 1.0; + constants[11] = 1.0; + constants[12] = 1.0; + constants[13] = 1.0; + constants[14] = 2.0; + computedConstants[2] = (1.0)?2.0:0.0; + computedConstants[3] = 1.0+((1.0)?2.0:0.0); + computedConstants[14] = 3.0; + computedConstants[16] = 2.0; + computedConstants[18] = -1.0e+18; + computedConstants[19] = 2.0; + computedConstants[21] = (1.0)?2.0:0.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[1] <= constants[0]; + computedConstants[1] = pow(constants[4], 2.5); + computedConstants[4] = constants[6] != constants[5]; + computedConstants[5] = constants[6] < constants[5]; + computedConstants[6] = constants[6] <= constants[5]; + computedConstants[7] = (0.0 < constants[6]) && (0.0 < constants[5]); + computedConstants[8] = (0.0 < constants[6]) || (0.0 < constants[5]); + computedConstants[9] = xor(0.0 < constants[6], 0.0 < constants[5]); + computedConstants[10] = constants[7]/(-1.0+NAN); + computedConstants[11] = !xor(constants[9] < constants[8], constants[9] < constants[10]); + computedConstants[12] = (0.0 < constants[11]) && (constants[11] == constants[12]); + computedConstants[13] = -5.0+pow(2.0, computedConstants[14]); + computedConstants[15] = -5.0+pow(computedConstants[16], 3.0); + computedConstants[17] = 1.0/computedConstants[14]; + computedConstants[20] = -pow(3.14159265358979, computedConstants[19]); + computedConstants[24] = 2.0-constants[14]-constants[13]; + computedConstants[25] = 3.0-constants[14]; + computedConstants[22] = 4.0-constants[13]-computedConstants[25]; + computedConstants[23] = -computedConstants[22]-computedConstants[24]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[0] = 1.0; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); +} diff --git a/tests/resources/analyser/symengine/differential.cellml b/tests/resources/analyser/symengine/differential.cellml new file mode 100644 index 0000000000..6ad3114313 --- /dev/null +++ b/tests/resources/analyser/symengine/differential.cellml @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + t + y + + x + + 0 + + + + + + ty + 1 + + + + diff --git a/tests/resources/analyser/symengine/exponential.cellml b/tests/resources/analyser/symengine/exponential.cellml new file mode 100644 index 0000000000..fa69167891 --- /dev/null +++ b/tests/resources/analyser/symengine/exponential.cellml @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + aw10 + 200 + + + + + + + b200 + 10 + + + + w2 + + + diff --git a/tests/resources/analyser/symengine/linear_system_2d.cellml b/tests/resources/analyser/symengine/linear_system_2d.cellml new file mode 100644 index 0000000000..5d66775726 --- /dev/null +++ b/tests/resources/analyser/symengine/linear_system_2d.cellml @@ -0,0 +1,39 @@ + + + + + + + + + + + + + x + y + + 3 + + + + + + + + + + 2 + x + + + + -1 + y + + + 0 + + + + diff --git a/tests/resources/analyser/symengine/linear_system_3d.cellml b/tests/resources/analyser/symengine/linear_system_3d.cellml new file mode 100644 index 0000000000..277dcedb34 --- /dev/null +++ b/tests/resources/analyser/symengine/linear_system_3d.cellml @@ -0,0 +1,82 @@ + + + + + + + + + + + + + + + + 2 + x + + + + 3 + y + + + + -1 + z + + + 4 + + + + + + + + + + 1 + x + + + + -4 + y + + + + 5 + z + + + 13 + + + + + + + + + + 3 + x + + + + 1 + y + + + + -2 + z + + + 1 + + + + diff --git a/tests/resources/analyser/symengine/linear_system_4d.cellml b/tests/resources/analyser/symengine/linear_system_4d.cellml new file mode 100644 index 0000000000..8d382a8134 --- /dev/null +++ b/tests/resources/analyser/symengine/linear_system_4d.cellml @@ -0,0 +1,63 @@ + + + + + + + + + + + + + + + 2a + 3b + -1c + 1d + + 8 + + + + + + + + a + -4b + 5c + -2d + + 5 + + + + + + + + 3a + 1b + -2c + 1d + + 5 + + + + + + + + a + b + c + d + + 10 + + + + diff --git a/tests/resources/analyser/symengine/logarithmic.cellml b/tests/resources/analyser/symengine/logarithmic.cellml new file mode 100644 index 0000000000..cce66e6226 --- /dev/null +++ b/tests/resources/analyser/symengine/logarithmic.cellml @@ -0,0 +1,45 @@ + + + + + + + + + + + + + + + + + + + ax + 5 + + + + + + + 3b + y + + + + + + + 2zc + 2.5 + + + + x3 + y1000 + z1.5 + + + diff --git a/tests/resources/analyser/symengine/multiplication.cellml b/tests/resources/analyser/symengine/multiplication.cellml new file mode 100644 index 0000000000..c1003536a3 --- /dev/null +++ b/tests/resources/analyser/symengine/multiplication.cellml @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + + + + + + + aw + 4 + + + + + + + + + b + y + + 18 + + + + + + + + + cz + x3 + + 10 + + + + w2 + x3 + y4 + z5 + + + diff --git a/tests/resources/analyser/symengine/polynomials.cellml b/tests/resources/analyser/symengine/polynomials.cellml new file mode 100644 index 0000000000..7da3465740 --- /dev/null +++ b/tests/resources/analyser/symengine/polynomials.cellml @@ -0,0 +1,69 @@ + + + + + + + + + + + + + + + + + + + + + + + a2 + 3 + + 125 + + + + + + + + + + b2 + 4b + 4 + + 0 + + + + + + + + + + c3 + 3c + + 36 + + + + + + + + d3 + w + + + + w3 + + + diff --git a/tests/resources/analyser/symengine/relational_and_logical_simplifications.c b/tests/resources/analyser/symengine/relational_and_logical_simplifications.c new file mode 100644 index 0000000000..8e1b7db173 --- /dev/null +++ b/tests/resources/analyser/symengine/relational_and_logical_simplifications.c @@ -0,0 +1,175 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t CONSTANT_COUNT = 1; +const size_t COMPUTED_CONSTANT_COUNT = 48; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; + +const VariableInfo CONSTANT_INFO[] = { + {"a", "dimensionless", "my_component"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"eqEqn1", "dimensionless", "my_component"}, + {"eqEqn2", "dimensionless", "my_component"}, + {"eqEqn3", "dimensionless", "my_component"}, + {"eqEqn4", "dimensionless", "my_component"}, + {"eqEqn5", "dimensionless", "my_component"}, + {"neqEqn1", "dimensionless", "my_component"}, + {"neqEqn2", "dimensionless", "my_component"}, + {"neqEqn3", "dimensionless", "my_component"}, + {"neqEqn4", "dimensionless", "my_component"}, + {"neqEqn5", "dimensionless", "my_component"}, + {"ltEqn1", "dimensionless", "my_component"}, + {"ltEqn2", "dimensionless", "my_component"}, + {"ltEqn3", "dimensionless", "my_component"}, + {"ltEqn4", "dimensionless", "my_component"}, + {"ltEqn5", "dimensionless", "my_component"}, + {"leqEqn1", "dimensionless", "my_component"}, + {"leqEqn2", "dimensionless", "my_component"}, + {"leqEqn3", "dimensionless", "my_component"}, + {"leqEqn4", "dimensionless", "my_component"}, + {"leqEqn5", "dimensionless", "my_component"}, + {"gtEqn1", "dimensionless", "my_component"}, + {"gtEqn2", "dimensionless", "my_component"}, + {"gtEqn3", "dimensionless", "my_component"}, + {"gtEqn4", "dimensionless", "my_component"}, + {"gtEqn5", "dimensionless", "my_component"}, + {"geqEqn1", "dimensionless", "my_component"}, + {"geqEqn2", "dimensionless", "my_component"}, + {"geqEqn3", "dimensionless", "my_component"}, + {"geqEqn4", "dimensionless", "my_component"}, + {"geqEqn5", "dimensionless", "my_component"}, + {"andEqn1", "dimensionless", "my_component"}, + {"andEqn2", "dimensionless", "my_component"}, + {"andEqn3", "dimensionless", "my_component"}, + {"andEqn4", "dimensionless", "my_component"}, + {"andEqn5", "dimensionless", "my_component"}, + {"orEqn1", "dimensionless", "my_component"}, + {"orEqn2", "dimensionless", "my_component"}, + {"orEqn3", "dimensionless", "my_component"}, + {"orEqn4", "dimensionless", "my_component"}, + {"orEqn5", "dimensionless", "my_component"}, + {"xorEqn1", "dimensionless", "my_component"}, + {"xorEqn2", "dimensionless", "my_component"}, + {"xorEqn3", "dimensionless", "my_component"}, + {"xorEqn4", "dimensionless", "my_component"}, + {"xorEqn5", "dimensionless", "my_component"}, + {"notEqn1", "dimensionless", "my_component"}, + {"notEqn2", "dimensionless", "my_component"}, + {"notEqn3", "dimensionless", "my_component"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { +}; + +double xor(double x, double y) +{ + return (x != 0.0) ^ (y != 0.0); +} + +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 *constants, double *computedConstants, double *algebraicVariables) +{ + constants[0] = 1.0; + computedConstants[3] = 1.0; + computedConstants[4] = 0.0; + computedConstants[8] = 1.0; + computedConstants[9] = 0.0; + computedConstants[13] = 1.0; + computedConstants[14] = 0.0; + computedConstants[18] = 1.0; + computedConstants[19] = 0.0; + computedConstants[23] = 1.0; + computedConstants[24] = 0.0; + computedConstants[28] = 1.0; + computedConstants[29] = 0.0; + computedConstants[33] = 1.0; + computedConstants[34] = 0.0; + computedConstants[38] = 1.0; + computedConstants[39] = 0.0; + computedConstants[43] = 1.0; + computedConstants[44] = 0.0; + computedConstants[46] = 1.0; + computedConstants[47] = 0.0; +} + +void computeComputedConstants(double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[0] == constants[0]; + computedConstants[1] = 1.0 == constants[0]; + computedConstants[2] = constants[0] == 1.0; + computedConstants[5] = constants[0] != constants[0]; + computedConstants[6] = 1.0 != constants[0]; + computedConstants[7] = constants[0] != 1.0; + computedConstants[10] = constants[0] < constants[0]; + computedConstants[11] = 1.0 < constants[0]; + computedConstants[12] = constants[0] < 1.0; + computedConstants[15] = constants[0] <= constants[0]; + computedConstants[16] = 1.0 <= constants[0]; + computedConstants[17] = constants[0] <= 1.0; + computedConstants[20] = constants[0] > constants[0]; + computedConstants[21] = 1.0 > constants[0]; + computedConstants[22] = constants[0] > 1.0; + computedConstants[25] = constants[0] >= constants[0]; + computedConstants[26] = 1.0 >= constants[0]; + computedConstants[27] = constants[0] >= 1.0; + computedConstants[30] = constants[0] && constants[0]; + computedConstants[31] = 1.0 && constants[0]; + computedConstants[32] = constants[0] && 1.0; + computedConstants[35] = constants[0] || constants[0]; + computedConstants[36] = 1.0 || constants[0]; + computedConstants[37] = constants[0] || 1.0; + computedConstants[40] = xor(constants[0], constants[0]); + computedConstants[41] = xor(1.0, constants[0]); + computedConstants[42] = xor(constants[0], 1.0); + computedConstants[45] = !constants[0]; +} + +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/analyser/symengine/relational_and_logical_simplifications.cellml b/tests/resources/analyser/symengine/relational_and_logical_simplifications.cellml new file mode 100644 index 0000000000..7cdb7c8c14 --- /dev/null +++ b/tests/resources/analyser/symengine/relational_and_logical_simplifications.cellml @@ -0,0 +1,163 @@ + + + + + + + + + + + + + + + + eqEqn1aa + eqEqn21a + eqEqn3a1 + eqEqn411 + eqEqn513 + + + + + + + + + + + + neqEqn1aa + neqEqn21a + neqEqn3a1 + neqEqn413 + neqEqn511 + + + + + + + + + + + + ltEqn1aa + ltEqn21a + ltEqn3a1 + ltEqn413 + ltEqn511 + + + + + + + + + + + + leqEqn1aa + leqEqn21a + leqEqn3a1 + leqEqn413 + leqEqn510 + + + + + + + + + + + + gtEqn1aa + gtEqn21a + gtEqn3a1 + gtEqn431 + gtEqn511 + + + + + + + + + + + + geqEqn1aa + geqEqn21a + geqEqn3a1 + geqEqn411 + geqEqn513 + + + + + + + + + + + + andEqn1aa + andEqn21a + andEqn3a1 + andEqn411 + andEqn510 + + + + + + + + + + + + orEqn1aa + orEqn21a + orEqn3a1 + orEqn410 + orEqn500 + + + + + + + + + + + + xorEqn1aa + xorEqn21a + xorEqn3a1 + xorEqn410 + xorEqn500 + + + + + + + + + + notEqn1a + notEqn20 + notEqn31 + + + diff --git a/tests/resources/analyser/symengine/simple_capillary.cellml b/tests/resources/analyser/symengine/simple_capillary.cellml new file mode 100644 index 0000000000..69ba965830 --- /dev/null +++ b/tests/resources/analyser/symengine/simple_capillary.cellml @@ -0,0 +1,113 @@ + + + + + + + + + + + + + + + + + + + + + v_in + + + v_y + v_z + + + + + P_x + + + P_out + P_R + + + + + P_x + + + P_R_v + P_C + + + + + + P_R + + + v_z + R + + + + + P_R_v + + + v_y + R_v + + + + + + + + t + + q + + v_y + + + + P_C + + + q + C + + + + + + v_in + 5.0 + + + + P_out + 10.0 + + + + R + 10.0 + + + + R_v + 10.0 + + + + C + 10.0 + + + + diff --git a/tests/resources/analyser/symengine/trigonometric.cellml b/tests/resources/analyser/symengine/trigonometric.cellml new file mode 100644 index 0000000000..3827196fd9 --- /dev/null +++ b/tests/resources/analyser/symengine/trigonometric.cellml @@ -0,0 +1,234 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 2az1 + 1 + + + + + + + 4z2b + 0 + + + + + + + c3z3 + 2 + + + + + + + 2dz1 + 1 + + + + + + + 4z2e + 0 + + + + + + + f3z3 + 2 + + + + + + + 2gz1 + 1 + + + + + + + 4z2h + 0 + + + + + + + i3z3 + 2 + + + + + + + 2jz1 + 1 + + + + + + + 4z2k + 0 + + + + + + + l3z3 + 2 + + + + + + + 2mz1 + 1 + + + + + + + 4z2n + 0 + + + + + + + o3z3 + 2 + + + + + + + 2pz1 + 1 + + + + + + + 4z2q + 0 + + + + + + + r3z3 + 2 + + + + + + + 2sz1 + 1 + + + + + + + 4z2t + 0 + + + + + + + u3z3 + 2 + + + + + + + 2vz1 + 1 + + + + + + + 4z2w + 0 + + + + + + + x3z3 + 2 + + + + z10.5 + z21.0 + z31.5 + + + diff --git a/tests/resources/analyser/symengine/trigonometric_simplifications.c b/tests/resources/analyser/symengine/trigonometric_simplifications.c new file mode 100644 index 0000000000..96f1a67787 --- /dev/null +++ b/tests/resources/analyser/symengine/trigonometric_simplifications.c @@ -0,0 +1,236 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t CONSTANT_COUNT = 1; +const size_t COMPUTED_CONSTANT_COUNT = 48; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; + +const VariableInfo CONSTANT_INFO[] = { + {"a", "dimensionless", "my_component"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"sinEqn1", "dimensionless", "my_component"}, + {"sinEqn2", "dimensionless", "my_component"}, + {"cosEqn1", "dimensionless", "my_component"}, + {"cosEqn2", "dimensionless", "my_component"}, + {"tanEqn1", "dimensionless", "my_component"}, + {"tanEqn2", "dimensionless", "my_component"}, + {"secEqn1", "dimensionless", "my_component"}, + {"secEqn2", "dimensionless", "my_component"}, + {"cscEqn1", "dimensionless", "my_component"}, + {"cscEqn2", "dimensionless", "my_component"}, + {"cotEqn1", "dimensionless", "my_component"}, + {"cotEqn2", "dimensionless", "my_component"}, + {"sinhEqn1", "dimensionless", "my_component"}, + {"sinhEqn2", "dimensionless", "my_component"}, + {"coshEqn1", "dimensionless", "my_component"}, + {"coshEqn2", "dimensionless", "my_component"}, + {"tanhEqn1", "dimensionless", "my_component"}, + {"tanhEqn2", "dimensionless", "my_component"}, + {"sechEqn1", "dimensionless", "my_component"}, + {"sechEqn2", "dimensionless", "my_component"}, + {"cschEqn1", "dimensionless", "my_component"}, + {"cschEqn2", "dimensionless", "my_component"}, + {"cothEqn1", "dimensionless", "my_component"}, + {"cothEqn2", "dimensionless", "my_component"}, + {"asinEqn1", "dimensionless", "my_component"}, + {"asinEqn2", "dimensionless", "my_component"}, + {"acosEqn1", "dimensionless", "my_component"}, + {"acosEqn2", "dimensionless", "my_component"}, + {"atanEqn1", "dimensionless", "my_component"}, + {"atanEqn2", "dimensionless", "my_component"}, + {"asecEqn1", "dimensionless", "my_component"}, + {"asecEqn2", "dimensionless", "my_component"}, + {"acscEqn1", "dimensionless", "my_component"}, + {"acscEqn2", "dimensionless", "my_component"}, + {"acotEqn1", "dimensionless", "my_component"}, + {"acotEqn2", "dimensionless", "my_component"}, + {"asinhEqn1", "dimensionless", "my_component"}, + {"asinhEqn2", "dimensionless", "my_component"}, + {"acoshEqn1", "dimensionless", "my_component"}, + {"acoshEqn2", "dimensionless", "my_component"}, + {"atanhEqn1", "dimensionless", "my_component"}, + {"atanhEqn2", "dimensionless", "my_component"}, + {"asechEqn1", "dimensionless", "my_component"}, + {"asechEqn2", "dimensionless", "my_component"}, + {"acschEqn1", "dimensionless", "my_component"}, + {"acschEqn2", "dimensionless", "my_component"}, + {"acothEqn1", "dimensionless", "my_component"}, + {"acothEqn2", "dimensionless", "my_component"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { +}; + +double sec(double x) +{ + return 1.0/cos(x); +} + +double csc(double x) +{ + return 1.0/sin(x); +} + +double cot(double x) +{ + return 1.0/tan(x); +} + +double sech(double x) +{ + return 1.0/cosh(x); +} + +double csch(double x) +{ + return 1.0/sinh(x); +} + +double coth(double x) +{ + return 1.0/tanh(x); +} + +double asec(double x) +{ + return acos(1.0/x); +} + +double acsc(double x) +{ + return asin(1.0/x); +} + +double acot(double x) +{ + return atan(1.0/x); +} + +double asech(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX-1.0)); +} + +double acsch(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX+1.0)); +} + +double acoth(double x) +{ + double oneOverX = 1.0/x; + + return 0.5*log((1.0+oneOverX)/(1.0-oneOverX)); +} + +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 *constants, double *computedConstants, double *algebraicVariables) +{ + constants[0] = 1.0; + computedConstants[1] = 0.479425538604203; + computedConstants[3] = 0.877582561890373; + computedConstants[5] = 0.54630248984379; + computedConstants[7] = 1.13949392732455; + computedConstants[9] = 2.08582964293349; + computedConstants[11] = 1.83048772171245; + computedConstants[13] = 0.521095305493747; + computedConstants[15] = 1.12762596520638; + computedConstants[17] = 0.46211715726001; + computedConstants[19] = 0.886818883970074; + computedConstants[21] = 1.91903475133494; + computedConstants[23] = 2.16395341373865; + computedConstants[25] = 0.523598775598299; + computedConstants[27] = 1.0471975511966; + computedConstants[29] = 0.463647609000806; + computedConstants[31] = 0.84106867056793; + computedConstants[33] = 0.729727656226966; + computedConstants[35] = 1.10714871779409; + computedConstants[37] = 0.481211825059603; + computedConstants[39] = 0.962423650119207; + computedConstants[41] = 0.549306144334055; + computedConstants[43] = 1.31695789692482; + computedConstants[45] = 1.44363547517881; + computedConstants[47] = 0.80471895621705; +} + +void computeComputedConstants(double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = sin(constants[0]); + computedConstants[2] = cos(constants[0]); + computedConstants[4] = tan(constants[0]); + computedConstants[6] = sec(constants[0]); + computedConstants[8] = csc(constants[0]); + computedConstants[10] = cot(constants[0]); + computedConstants[12] = sinh(constants[0]); + computedConstants[14] = cosh(constants[0]); + computedConstants[16] = tanh(constants[0]); + computedConstants[18] = sech(constants[0]); + computedConstants[20] = csch(constants[0]); + computedConstants[22] = coth(constants[0]); + computedConstants[24] = asin(constants[0]); + computedConstants[26] = acos(constants[0]); + computedConstants[28] = atan(constants[0]); + computedConstants[30] = asec(constants[0]); + computedConstants[32] = acsc(constants[0]); + computedConstants[34] = acot(constants[0]); + computedConstants[36] = asinh(constants[0]); + computedConstants[38] = acosh(constants[0]); + computedConstants[40] = atanh(constants[0]); + computedConstants[42] = asech(constants[0]); + computedConstants[44] = acsch(constants[0]); + computedConstants[46] = acoth(constants[0]); +} + +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/analyser/symengine/trigonometric_simplifications.cellml b/tests/resources/analyser/symengine/trigonometric_simplifications.cellml new file mode 100644 index 0000000000..7d64515cd5 --- /dev/null +++ b/tests/resources/analyser/symengine/trigonometric_simplifications.cellml @@ -0,0 +1,247 @@ + + + + + + + + + + + + + sinEqn1a + sinEqn20.5 + + + + + + + + + cosEqn1a + cosEqn20.5 + + + + + + + + + tanEqn1a + tanEqn20.5 + + + + + + + + + secEqn1a + secEqn20.5 + + + + + + + + + cscEqn1a + cscEqn20.5 + + + + + + + + + cotEqn1a + cotEqn20.5 + + + + + + + + + sinhEqn1a + sinhEqn20.5 + + + + + + + + + coshEqn1a + coshEqn20.5 + + + + + + + + + tanhEqn1a + tanhEqn20.5 + + + + + + + + + sechEqn1a + sechEqn20.5 + + + + + + + + + cschEqn1a + cschEqn20.5 + + + + + + + + + cothEqn1a + cothEqn20.5 + + + + + + + + + asinEqn1a + asinEqn20.5 + + + + + + + + + acosEqn1a + acosEqn20.5 + + + + + + + + + atanEqn1a + atanEqn20.5 + + + + + + + + + asecEqn1a + asecEqn21.5 + + + + + + + + + acscEqn1a + acscEqn21.5 + + + + + + + + + acotEqn1a + acotEqn20.5 + + + + + + + + + asinhEqn1a + asinhEqn20.5 + + + + + + + + + acoshEqn1a + acoshEqn21.5 + + + + + + + + + atanhEqn1a + atanhEqn20.5 + + + + + + + + + asechEqn1a + asechEqn20.5 + + + + + + + + + acschEqn1a + acschEqn20.5 + + + + + + + + + acothEqn1a + acothEqn21.5 + + + diff --git a/tests/resources/analyser/symengine/uncommon_arithmetic.cellml b/tests/resources/analyser/symengine/uncommon_arithmetic.cellml new file mode 100644 index 0000000000..17b079ca98 --- /dev/null +++ b/tests/resources/analyser/symengine/uncommon_arithmetic.cellml @@ -0,0 +1,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + aw + 2 + + + + + + b4w + 1 + + + + + + + cxy + 3 + + + + + + + + + d + x0.4 + + w + + + + + + + + + e + z2 + + 1 + + + + + + + xyf + 5 + + + + + + + yzg + w + + + + + + + hzw + 0 + + + + w2 + x3 + y4 + z5 + + + diff --git a/tests/resources/analyser/symengine/unrearrangeable.cellml b/tests/resources/analyser/symengine/unrearrangeable.cellml new file mode 100644 index 0000000000..c10215ad87 --- /dev/null +++ b/tests/resources/analyser/symengine/unrearrangeable.cellml @@ -0,0 +1,226 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 2x1a + 1 + + + + + + + 4bx2 + 0 + + + + + + + x13c + 2 + + + + + + + dx2 + 1 + + + + + + + ex1 + 0.5 + + + + + + + f2 + x2 + + + + + + + x1g + 1 + + + + + + + h1x1 + 0 + + + + + + + i23i2 + 0 + + + + + + + j + x1 + + + + + + + x2k + 0 + + + + + + + lx1 + 3 + + + + + + + m2.5 + 30 + + + + + + + 2n + 16 + + + + + + + x2 + + + x1 + x10 + + + o + + + + + + + + + pp + x3 + + + + + + + qx1 + 0 + + + + + + + r + 5 + + + + + + + sx2 + 3 + + + + + + + tx1 + x2 + + + + + + + u2x1 + 1 + + + + + + + v3 + x2 + + + + x10.5 + x21.0 + x31.5 + + + diff --git a/tests/resources/analyser/symengine/winograd_destexhe_sanchezvives_2008.cellml b/tests/resources/analyser/symengine/winograd_destexhe_sanchezvives_2008.cellml new file mode 100644 index 0000000000..a69d48f8df --- /dev/null +++ b/tests/resources/analyser/symengine/winograd_destexhe_sanchezvives_2008.cellml @@ -0,0 +1,1916 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + time + + V + + + + + + 0.001 + + + + + + + + + + + + + I_app + + + I_leak + + + I_Na + + I_KD + + I_KM + + I_CaL + + I_h + + + C_m + + + + + + + + + + + + + + + + tau + + + time + + + period + + + + + time + period + + + + + + + + I_app + + + i_stimAmplitude + + + + + tau + i_stimStart + + + + tau + i_stimEnd + + + + + 0 + + + + + + + + + + + + + + I_leak + + + 1000 + g_leak + + + V + E_leak + + + + + + + + + + + + + + + + + + + I_Na + + + 1000 + g_Na + + + m + 3 + + h + + + V + E_Na + + + + + + + + + + + + + + + + + + alpha + + + + + 0.32 + 4 + + + 1 + + + + + + + 13 + V_T + + V + + + + 2 + 4 + + + + + + + + + + + + + + + 13 + V_T + + V + + 4 + + + 0.000001 + + + + + + + + 0.32 + + + + + 13 + V_T + + V + + + + + + + + + + + + + 13 + V_T + + V + + 4 + + + 1 + + + + + + + + beta + + + + + + + 0.28 + + 5 + + + 1 + + + + + + + + + V + V_T + + 40 + + + + + 2 + 5 + + + + + + + + + + + + + + + + + V + V_T + + 40 + + + 5 + + + 0.000001 + + + + + + + + + + 0.28 + + + + + + V + V_T + + 40 + + + + + + + + + + + + + + + V + V_T + + 40 + + + 5 + + + 1 + + + + + + + + tau_m + + + 1 + + + alpha + beta + + + + + + m_inf + + + alpha + + + alpha + beta + + + + + + + + + time + + m + + + + + + m_inf + m + + tau_m + + + + + + + + + + + + + + + + + + alpha_h + + + 0.128 + + + + + + + + + 17 + V_T + V_S + + V + + 18 + + + + + + + beta_h + + + 4 + + + 1 + + + + + + + + + 40 + V_S + V_T + + V + + 5 + + + + + + + + tau_h + + + 1 + + + alpha_h + beta_h + + + + + + h_inf + + + alpha_h + + + alpha_h + beta_h + + + + + + + + + time + + h + + + + + + h_inf + h + + tau_h + + + + + + + + + + + + + + + + I_KD + + + 1000 + g_KD + + + n + 4 + + + + V + E_K + + + + + + + + + + + + + + + + + + alpha_n + + + + + + + 0.032 + + 5 + + + 1 + + + + + + + V + V_T + + 15 + + + + 2 + 5 + + + + + + + + + + + + + + + V + V_T + + 15 + + 5 + + + 0.000001 + + + + + + + + + + 0.032 + + + + + + V + V_T + + 15 + + + + + + + + + + + + + V + V_T + + 15 + + 5 + + + 1 + + + + + + + + beta_n + + + + + 0.5 + 40 + + + 1 + + + + + + + V + V_T + + 10 + + + + 2 + 40 + + + + + + + + + + + + + + + + + V + V_T + + 10 + + + 40 + + + 0.000001 + + + + + + + + 0.5 + + + + + + + V + V_T + + 10 + + + + + + + + + + + + + + + + V + V_T + + 10 + + + 40 + + + 1 + + + + + + + + tau_n + + + 1 + + + alpha_n + beta_n + + + + + + n_inf + + + alpha_n + + + alpha_n + beta_n + + + + + + + + + time + + n + + + + + + n_inf + n + + tau_n + + + + + + + + + + + + + + + I_KM + + + 1000 + g_KM + p + + + V + E_K + + + + + + + + + + + + + + + + p_inf + + + + + 1 + + + 1 + + + + + + + + + V + 35 + + + 10 + + + + + + + + + + + + + + + V + 35 + + + 10 + + 25 + + + + + + + + + + V + 35 + + + 10 + + + + 25 + + + + + + 1 + + + + + + tau_p + + + + + tau_max + + + + + 3.3 + + + + + + + V + 35 + + 20 + + + + + + + + + + + + V + 35 + + + 20 + + + + + + + + + + + + + V + 35 + + 20 + + 25 + + + + + + + + V + 35 + + 20 + + + + 25 + + + + + + 1 + + + + + + + + + time + + p + + + + + + p_inf + p + + tau_p + + + + + + + + + + + + + + + I_CaL + + + 1000 + P_Ca + + + q + 2 + + G + + + + + + + + + + + + + + + + alpha_q + + + 6.32 + + + 1 + + + + + + + + + V + 5 + + + 13.89 + + + + + + + + beta_q + + + + + 0.02 + + + 5.36 + + + + + 1.31 + V + + 2 + + + + + + + + + + + + 1.31 + V + + 5.36 + + + 0.000001 + + + + + + + + 0.02 + + + 1.31 + V + + + + + 1 + + + + + + + V + 1.31 + + 5.36 + + + + + + + + + + tau_q + + + 1 + + + alpha_q + beta_q + + + + + + q_inf + + + 1 + + + 1 + + + + + + + V + 10 + + + + 10 + + + + + + + + + + + + time + + q + + + + + + q_inf + q + + tau_q + + + + + + + + + + + + + + + + + + + G + + + + + + + + + + + Z + 2 + + + + F + 2 + + 0.001 + V + + + + R + T + + + 0.000001 + + + Ca_i + + + Ca_o + + + + + + + Z + F + 0.001 + V + + + + R + T + + + + + + + + + 1 + + + + + + + 0.001 + Z + F + V + + + + R + T + + + + + + + + + + + + + + + + + + + + + + + + drive_channel + + + + + k + I_CaL + + + + 2 + F + d + + + + + + + + + time + + Ca_i + + + + + + + + Ca_inf + Ca_i + + tau_r + + + + drive_channel + 0 + + + + + + drive_channel + + + + + Ca_inf + Ca_i + + tau_r + + + + + + + + + + + + + + + + + + + + + + + m + + + o_1 + g_inc + o_2 + + + + + I_h + + + 1000 + g_hbar + m + + + V + E_h + + + + + + + + + + + + + + + + + + + + + p_0 + + + + + p_1 + k_2 + + k_1Ca + + + + + p_1 + + + 1 + p_0 + + + + + c_1 + + + + + beta + alpha + + o_1 + + + + + o_1 + + + + + k_4 + k_3p + + o_2 + + + + + o_2 + + + + + 1 + c_1 + + o_1 + + + + + + + + + + + + + + + + + + + + + + + + + + + h_inf + + + 1 + + + 1 + + + + + + + + + V + 75 + + V_S + + 5.5 + + + + + + + + tau_s + + + tau_m + + + 1000 + + + + + + + + + + + V + 71.55 + + V_S + + 14.2 + + + + + + + + + + + + + V + 89 + + V_S + + + 11.6 + + + + + + + + + alpha + + + h_inf + tau_s + + + + + beta + + + + + 1 + h_inf + + tau_s + + + + + k_1Ca + + + k_2 + + + + + Ca_i + Ca_c + + n_Ca + + + + + + k_3p + + + k_4 + + + + + p_1 + p_C + + n_exp + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/resources/analyser/underconstrained_nla_system.cellml b/tests/resources/analyser/underconstrained_nla_system.cellml index 38a29f9303..4d36968771 100644 --- a/tests/resources/analyser/underconstrained_nla_system.cellml +++ b/tests/resources/analyser/underconstrained_nla_system.cellml @@ -1,15 +1,15 @@ - - - + + + diff --git a/tests/resources/analyser/units/power_values.cellml b/tests/resources/analyser/units/power_values.cellml index 86a0b5b5c2..3521daf838 100644 --- a/tests/resources/analyser/units/power_values.cellml +++ b/tests/resources/analyser/units/power_values.cellml @@ -1081,6 +1081,11 @@ + + + u + z + eqnCoverage diff --git a/tests/resources/analyser/unsuitably_constrained_nla_system.cellml b/tests/resources/analyser/unsuitably_constrained_nla_system.cellml index c53a42e1f9..0e2b577e34 100644 --- a/tests/resources/analyser/unsuitably_constrained_nla_system.cellml +++ b/tests/resources/analyser/unsuitably_constrained_nla_system.cellml @@ -1,23 +1,23 @@ - - - + + + @@ -52,9 +52,9 @@ 31 - - - + + + diff --git a/tests/resources/analyser/variable_initialised_using_another_variable.cellml b/tests/resources/analyser/variable_initialised_using_another_variable.cellml index 46bae06b65..9b5ef3d159 100644 --- a/tests/resources/analyser/variable_initialised_using_another_variable.cellml +++ b/tests/resources/analyser/variable_initialised_using_another_variable.cellml @@ -1,6 +1,6 @@ - @@ -62,45 +34,6 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -112,19 +45,6 @@ - - - - - - - - - - - - - @@ -242,231 +162,6 @@ - - - - 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 - - - - - @@ -554,65 +249,5 @@ 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.cellml b/tests/resources/coverage/generator/model.cellml index 4b8fb9fc45..171fb0c21b 100644 --- a/tests/resources/coverage/generator/model.cellml +++ b/tests/resources/coverage/generator/model.cellml @@ -210,10 +210,11 @@ - - + + + @@ -3378,24 +3379,40 @@ - eqnNlaVariable1 - eqnNlaVariable2 + + + eqnNlaVariable1 + + + + eqnNlaVariable2 + x + m + eqnComputedConstant3 - 0 + 1 - eqnNlaVariable1 - eqnNlaVariable2 - - - - eqnComputedConstant1 - eqnComputedConstant2 + + + eqnNlaVariable1 + + + + + + eqnNlaVariable2 + + eqnComputedConstant1 + eqnComputedConstant2 + eqnComputedConstant3 + + 0.5 @@ -3409,6 +3426,15 @@ eqnComputedConstant2 3 + + + eqnComputedConstant3 + + + eqnComputedConstant1 + eqnComputedConstant2 + + diff --git a/tests/resources/coverage/generator/model.implementation_linux.out b/tests/resources/coverage/generator/model.implementation_linux.out new file mode 100644 index 0000000000..8fb8530b7d --- /dev/null +++ b/tests/resources/coverage/generator/model.implementation_linux.out @@ -0,0 +1,415 @@ +/* The content of this file was generated using a modified C profile of libCellML 0.7.0. */ + +double xor(double x, double y) +{ + return (x != 0.0) ^ (y != 0.0); +} + +double min(double x, double y) +{ + return (x < y)?x:y; +} + +double max(double x, double y) +{ + return (x > y)?x:y; +} + +double sec(double x) +{ + return 1.0/cos(x); +} + +double csc(double x) +{ + return 1.0/sin(x); +} + +double cot(double x) +{ + return 1.0/tan(x); +} + +double sech(double x) +{ + return 1.0/cosh(x); +} + +double csch(double x) +{ + return 1.0/sinh(x); +} + +double coth(double x) +{ + return 1.0/tanh(x); +} + +double asec(double x) +{ + return acos(1.0/x); +} + +double acsc(double x) +{ + return asin(1.0/x); +} + +double acot(double x) +{ + return atan(1.0/x); +} + +double asech(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX-1.0)); +} + +double acsch(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX+1.0)); +} + +double acoth(double x) +{ + double oneOverX = 1.0/x; + + return 0.5*log((1.0+oneOverX)/(1.0-oneOverX)); +} + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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; + double *externalVariables; +} 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; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; + + f[0] = sin(algebraicVariables[1])+sin(algebraicVariables[0])+states[0]+computedConstants[197]+constants[1]-1.0; + f[1] = -sin(algebraicVariables[0])+sin(algebraicVariables[1])-computedConstants[199]-computedConstants[197]-computedConstants[198]-0.5; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; + double u[2]; + + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; + + nlaSolve(objectiveFunction0, u, 2, &rfi); + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + constants[0] = 1.23; + constants[1] = 123.0; + constants[2] = 1.0e1; + constants[3] = 1.23e1; + constants[4] = 1.0E1; + constants[5] = 1.23E1; + constants[6] = 7.0; + computedConstants[176] = 123.0; + computedConstants[177] = 123.456789; + computedConstants[178] = 123.0e99; + computedConstants[179] = 123.456789e99; + computedConstants[181] = 1.0; + computedConstants[182] = 0.0; + computedConstants[183] = 2.71828182845905; + computedConstants[184] = 3.14159265358979; + computedConstants[185] = INFINITY; + computedConstants[186] = NAN; + computedConstants[199] = 1.0; + computedConstants[198] = 3.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = eq(constants[1], constants[0]); + computedConstants[1] = constants[1]/eq(constants[0], constants[0]); + computedConstants[2] = neq(constants[1], constants[0]); + computedConstants[3] = constants[1]/neq(constants[0], constants[2]); + computedConstants[4] = lt(constants[1], constants[0]); + computedConstants[5] = constants[1]/lt(constants[0], constants[2]); + computedConstants[6] = leq(constants[1], constants[0]); + computedConstants[7] = constants[1]/leq(constants[0], constants[2]); + computedConstants[8] = gt(constants[1], constants[0]); + computedConstants[9] = constants[1]/gt(constants[0], constants[2]); + computedConstants[10] = geq(constants[1], constants[0]); + computedConstants[11] = constants[1]/geq(constants[0], constants[2]); + computedConstants[12] = and(constants[1], constants[0]); + computedConstants[13] = and(constants[1], and(constants[0], constants[2])); + computedConstants[14] = and(lt(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[15] = and(constants[1]+constants[0], gt(constants[2], constants[3])); + computedConstants[16] = and(constants[1], gt(constants[0], constants[2])); + computedConstants[17] = and(constants[1]-constants[0], gt(constants[2], constants[3])); + computedConstants[18] = and(-constants[1], gt(constants[0], constants[2])); + computedConstants[19] = and(pow(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[20] = and(pow(constants[1], 1.0/constants[0]), gt(constants[2], constants[3])); + computedConstants[21] = and(lt(constants[1], constants[0]), constants[2]+constants[3]); + computedConstants[22] = and(lt(constants[1], constants[0]), constants[2]); + computedConstants[23] = and(lt(constants[1], constants[0]), constants[2]-constants[3]); + computedConstants[24] = and(lt(constants[1], constants[0]), -constants[2]); + computedConstants[25] = and(lt(constants[1], constants[0]), pow(constants[2], constants[3])); + computedConstants[26] = and(lt(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])); + computedConstants[27] = constants[1]/and(constants[0], constants[2]); + computedConstants[28] = or(constants[1], constants[0]); + computedConstants[29] = or(constants[1], or(constants[0], constants[2])); + computedConstants[30] = or(lt(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[31] = or(constants[1]+constants[0], gt(constants[2], constants[3])); + computedConstants[32] = or(constants[1], gt(constants[0], constants[2])); + computedConstants[33] = or(constants[1]-constants[0], gt(constants[2], constants[3])); + computedConstants[34] = or(-constants[1], gt(constants[0], constants[2])); + computedConstants[35] = or(pow(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[36] = or(pow(constants[1], 1.0/constants[0]), gt(constants[2], constants[3])); + computedConstants[37] = or(lt(constants[1], constants[0]), constants[2]+constants[3]); + computedConstants[38] = or(lt(constants[1], constants[0]), constants[2]); + computedConstants[39] = or(lt(constants[1], constants[0]), constants[2]-constants[3]); + computedConstants[40] = or(lt(constants[1], constants[0]), -constants[2]); + computedConstants[41] = or(lt(constants[1], constants[0]), pow(constants[2], constants[3])); + computedConstants[42] = or(lt(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])); + computedConstants[43] = constants[1]/or(constants[0], constants[2]); + computedConstants[44] = xor(constants[1], constants[0]); + computedConstants[45] = xor(constants[1], xor(constants[0], constants[2])); + computedConstants[46] = xor(lt(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[47] = xor(constants[1]+constants[0], gt(constants[2], constants[3])); + computedConstants[48] = xor(constants[1], gt(constants[0], constants[2])); + computedConstants[49] = xor(constants[1]-constants[0], gt(constants[2], constants[3])); + computedConstants[50] = xor(-constants[1], gt(constants[0], constants[2])); + computedConstants[51] = xor(pow(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[52] = xor(pow(constants[1], 1.0/constants[0]), gt(constants[2], constants[3])); + computedConstants[53] = xor(lt(constants[1], constants[0]), constants[2]+constants[3]); + computedConstants[54] = xor(lt(constants[1], constants[0]), constants[2]); + computedConstants[55] = xor(lt(constants[1], constants[0]), constants[2]-constants[3]); + computedConstants[56] = xor(lt(constants[1], constants[0]), -constants[2]); + computedConstants[57] = xor(lt(constants[1], constants[0]), pow(constants[2], constants[3])); + computedConstants[58] = xor(lt(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])); + computedConstants[59] = constants[1]/xor(constants[0], constants[2]); + computedConstants[60] = not(constants[1]); + computedConstants[61] = constants[1]+constants[0]+constants[2]; + computedConstants[62] = lt(constants[1], constants[0])+gt(constants[2], constants[3]); + computedConstants[63] = constants[1]; + computedConstants[64] = constants[1]-constants[0]; + computedConstants[65] = lt(constants[1], constants[0])-gt(constants[2], constants[3]); + computedConstants[66] = lt(constants[1], constants[0])-(constants[2]+constants[3]); + computedConstants[67] = lt(constants[1], constants[0])-constants[2]; + computedConstants[68] = constants[1]-(-constants[0]); + computedConstants[69] = constants[1]-(-constants[0]*constants[2]); + computedConstants[70] = -constants[1]; + computedConstants[71] = -lt(constants[1], constants[0]); + computedConstants[72] = constants[1]*constants[0]; + computedConstants[73] = constants[1]*constants[0]*constants[2]; + computedConstants[74] = lt(constants[1], constants[0])*gt(constants[2], constants[3]); + computedConstants[75] = (constants[1]+constants[0])*gt(constants[2], constants[3]); + computedConstants[76] = constants[1]*gt(constants[0], constants[2]); + computedConstants[77] = (constants[1]-constants[0])*gt(constants[2], constants[3]); + computedConstants[78] = -constants[1]*gt(constants[0], constants[2]); + computedConstants[79] = lt(constants[1], constants[0])*(constants[2]+constants[3]); + computedConstants[80] = lt(constants[1], constants[0])*constants[2]; + computedConstants[81] = lt(constants[1], constants[0])*(constants[2]-constants[3]); + computedConstants[82] = lt(constants[1], constants[0])*-constants[2]; + computedConstants[83] = constants[1]/constants[0]; + computedConstants[84] = lt(constants[1], constants[0])/gt(constants[3], constants[2]); + computedConstants[85] = (constants[1]+constants[0])/gt(constants[3], constants[2]); + computedConstants[86] = constants[1]/gt(constants[2], constants[0]); + computedConstants[87] = (constants[1]-constants[0])/gt(constants[3], constants[2]); + computedConstants[88] = -constants[1]/gt(constants[2], constants[0]); + computedConstants[89] = lt(constants[1], constants[0])/(constants[2]+constants[3]); + computedConstants[90] = lt(constants[1], constants[0])/constants[2]; + computedConstants[91] = lt(constants[1], constants[0])/(constants[2]-constants[3]); + computedConstants[92] = lt(constants[1], constants[0])/-constants[2]; + computedConstants[93] = lt(constants[1], constants[0])/(constants[2]*constants[3]); + computedConstants[94] = lt(constants[1], constants[0])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[1]); + computedConstants[96] = pow(constants[1], 2.0); + computedConstants[97] = pow(constants[1], 3.0); + computedConstants[98] = pow(constants[1], constants[0]); + computedConstants[99] = pow(leq(constants[1], constants[0]), geq(constants[2], constants[3])); + computedConstants[100] = pow(constants[1]+constants[0], geq(constants[2], constants[3])); + computedConstants[101] = pow(constants[1], geq(constants[0], constants[2])); + computedConstants[102] = pow(constants[1]-constants[0], geq(constants[2], constants[3])); + computedConstants[103] = pow(-constants[1], geq(constants[0], constants[2])); + computedConstants[104] = pow(constants[1]*constants[0], geq(constants[2], constants[3])); + computedConstants[105] = pow(constants[1]/constants[0], geq(constants[2], constants[3])); + computedConstants[106] = pow(leq(constants[1], constants[0]), constants[2]+constants[3]); + computedConstants[107] = pow(leq(constants[1], constants[0]), constants[2]); + computedConstants[108] = pow(leq(constants[1], constants[0]), constants[2]-constants[3]); + computedConstants[109] = pow(leq(constants[1], constants[0]), -constants[2]); + computedConstants[110] = pow(leq(constants[1], constants[0]), constants[2]*constants[3]); + computedConstants[111] = pow(leq(constants[1], constants[0]), constants[2]/constants[3]); + computedConstants[112] = pow(leq(constants[1], constants[0]), pow(constants[2], constants[3])); + computedConstants[113] = pow(leq(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])); + computedConstants[114] = sqrt(constants[1]); + computedConstants[115] = sqrt(constants[1]); + computedConstants[116] = pow(constants[1], 1.0/3.0); + computedConstants[117] = pow(constants[1], 1.0/constants[0]); + computedConstants[118] = pow(lt(constants[1], constants[0]), 1.0/gt(constants[3], constants[2])); + computedConstants[119] = pow(constants[1]+constants[0], 1.0/gt(constants[3], constants[2])); + computedConstants[120] = pow(constants[1], 1.0/gt(constants[2], constants[0])); + computedConstants[121] = pow(constants[1]-constants[0], 1.0/gt(constants[3], constants[2])); + computedConstants[122] = pow(-constants[1], 1.0/gt(constants[2], constants[0])); + computedConstants[123] = pow(constants[1]*constants[0], 1.0/gt(constants[3], constants[2])); + computedConstants[124] = pow(constants[1]/constants[0], 1.0/gt(constants[3], constants[2])); + computedConstants[125] = pow(lt(constants[1], constants[0]), 1.0/(constants[2]+constants[3])); + computedConstants[126] = pow(lt(constants[1], constants[0]), 1.0/constants[2]); + computedConstants[127] = pow(lt(constants[1], constants[0]), 1.0/(constants[2]-constants[3])); + computedConstants[128] = pow(lt(constants[1], constants[0]), 1.0/-constants[2]); + computedConstants[129] = pow(lt(constants[1], constants[0]), 1.0/(constants[2]*constants[3])); + computedConstants[130] = pow(lt(constants[1], constants[0]), 1.0/(constants[2]/constants[3])); + computedConstants[131] = pow(lt(constants[1], constants[0]), 1.0/pow(constants[2], constants[3])); + computedConstants[132] = pow(lt(constants[1], constants[0]), 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[133] = fabs(constants[1]); + computedConstants[134] = exp(constants[1]); + computedConstants[135] = log(constants[1]); + computedConstants[136] = log10(constants[1]); + computedConstants[137] = log(constants[1])/log(2.0); + computedConstants[138] = log10(constants[1]); + computedConstants[139] = log(constants[1])/log(constants[0]); + computedConstants[140] = ceil(constants[1]); + computedConstants[141] = floor(constants[1]); + computedConstants[142] = min(constants[1], constants[0]); + computedConstants[143] = min(constants[1], min(constants[0], constants[2])); + computedConstants[144] = max(constants[1], constants[0]); + computedConstants[145] = max(constants[1], max(constants[0], constants[2])); + computedConstants[146] = fmod(constants[1], constants[0]); + computedConstants[147] = sin(constants[1]); + computedConstants[148] = cos(constants[1]); + computedConstants[149] = tan(constants[1]); + computedConstants[150] = sec(constants[1]); + computedConstants[151] = csc(constants[1]); + computedConstants[152] = cot(constants[1]); + computedConstants[153] = sinh(constants[1]); + computedConstants[154] = cosh(constants[1]); + computedConstants[155] = tanh(constants[1]); + computedConstants[156] = sech(constants[1]); + computedConstants[157] = csch(constants[1]); + computedConstants[158] = coth(constants[1]); + computedConstants[159] = asin(constants[1]); + computedConstants[160] = acos(constants[1]); + computedConstants[161] = atan(constants[1]); + computedConstants[162] = asec(constants[1]); + computedConstants[163] = acsc(constants[1]); + computedConstants[164] = acot(constants[1]); + computedConstants[165] = asinh(constants[1]); + computedConstants[166] = acosh(constants[1]); + computedConstants[167] = atanh(constants[1]/2.0); + computedConstants[168] = asech(constants[1]); + computedConstants[169] = acsch(constants[1]); + computedConstants[170] = acoth(2.0*constants[1]); + computedConstants[171] = (gt(constants[1], constants[0]))?constants[1]:NAN; + computedConstants[172] = (gt(constants[1], constants[0]))?constants[1]:constants[2]; + computedConstants[173] = (gt(constants[1], constants[0]))?constants[1]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:NAN; + computedConstants[174] = (gt(constants[1], constants[0]))?constants[1]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:constants[6]; + computedConstants[175] = 123.0+((gt(constants[1], constants[0]))?constants[1]:NAN); + computedConstants[180] = constants[1]; + computedConstants[187] = and(constants[1], constants[0])+((gt(constants[2], constants[3]))?constants[0]:NAN)+constants[4]+and(constants[5], constants[6]); + computedConstants[188] = and(constants[1], constants[0])-(((gt(constants[2], constants[3]))?constants[0]:NAN)-(constants[4]-((gt(constants[2], constants[3]))?constants[0]:NAN)))-and(constants[5], constants[6]); + computedConstants[189] = and(constants[1], constants[0])*((gt(constants[2], constants[3]))?constants[0]:NAN)*constants[4]*((gt(constants[2], constants[3]))?constants[0]:NAN)*and(constants[5], constants[6]); + computedConstants[190] = and(constants[1], constants[0])/(((gt(constants[2], constants[3]))?constants[0]:NAN)/(constants[4]/((gt(constants[2], constants[3]))?constants[0]:NAN))); + computedConstants[191] = and(or(constants[1], constants[0]), and(xor(constants[1], constants[0]), and((gt(constants[2], constants[3]))?constants[0]:NAN, and(and(and(constants[4], (gt(constants[2], constants[3]))?constants[0]:NAN), xor(constants[1], constants[0])), or(constants[1], constants[0]))))); + computedConstants[192] = or(and(constants[1], constants[0]), or(xor(constants[1], constants[0]), or((gt(constants[2], constants[3]))?constants[0]:NAN, or(or(or(constants[4], (gt(constants[2], constants[3]))?constants[0]:NAN), xor(constants[1], constants[0])), and(constants[1], constants[0]))))); + computedConstants[193] = xor(and(constants[1], constants[0]), xor(or(constants[1], constants[0]), xor((gt(constants[2], constants[3]))?constants[0]:NAN, xor(xor(xor(constants[4], (gt(constants[2], constants[3]))?constants[0]:NAN), or(constants[1], constants[0])), and(constants[1], constants[0]))))); + computedConstants[194] = pow(and(constants[1], constants[0]), pow((gt(constants[2], constants[3]))?constants[0]:NAN, pow(pow(constants[4], (gt(constants[2], constants[3]))?constants[0]:NAN), and(constants[1], constants[0])))); + computedConstants[195] = pow(pow(pow(and(constants[1], constants[0]), 1.0/pow((gt(constants[2], constants[3]))?constants[0]:NAN, 1.0/constants[4])), 1.0/((gt(constants[2], constants[3]))?constants[0]:NAN)), 1.0/and(constants[1], constants[0])); + computedConstants[196] = -and(constants[1], constants[0])-((gt(constants[2], constants[3]))?constants[0]:NAN); + computedConstants[197] = computedConstants[199]+computedConstants[198]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + rates[0] = 1.0; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); +} diff --git a/tests/resources/coverage/generator/model.implementation_macos.out b/tests/resources/coverage/generator/model.implementation_macos.out new file mode 100644 index 0000000000..2d79225d1a --- /dev/null +++ b/tests/resources/coverage/generator/model.implementation_macos.out @@ -0,0 +1,415 @@ +/* The content of this file was generated using a modified C profile of libCellML 0.7.0. */ + +double xor(double x, double y) +{ + return (x != 0.0) ^ (y != 0.0); +} + +double min(double x, double y) +{ + return (x < y)?x:y; +} + +double max(double x, double y) +{ + return (x > y)?x:y; +} + +double sec(double x) +{ + return 1.0/cos(x); +} + +double csc(double x) +{ + return 1.0/sin(x); +} + +double cot(double x) +{ + return 1.0/tan(x); +} + +double sech(double x) +{ + return 1.0/cosh(x); +} + +double csch(double x) +{ + return 1.0/sinh(x); +} + +double coth(double x) +{ + return 1.0/tanh(x); +} + +double asec(double x) +{ + return acos(1.0/x); +} + +double acsc(double x) +{ + return asin(1.0/x); +} + +double acot(double x) +{ + return atan(1.0/x); +} + +double asech(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX-1.0)); +} + +double acsch(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX+1.0)); +} + +double acoth(double x) +{ + double oneOverX = 1.0/x; + + return 0.5*log((1.0+oneOverX)/(1.0-oneOverX)); +} + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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; + double *externalVariables; +} 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; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; + + f[0] = sin(algebraicVariables[1])+sin(algebraicVariables[0])+states[0]+computedConstants[197]+constants[1]-1.0; + f[1] = -computedConstants[197]-sin(algebraicVariables[0])-computedConstants[198]-computedConstants[199]+sin(algebraicVariables[1])-0.5; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; + double u[2]; + + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; + + nlaSolve(objectiveFunction0, u, 2, &rfi); + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + constants[0] = 1.23; + constants[1] = 123.0; + constants[2] = 1.0e1; + constants[3] = 1.23e1; + constants[4] = 1.0E1; + constants[5] = 1.23E1; + constants[6] = 7.0; + computedConstants[176] = 123.0; + computedConstants[177] = 123.456789; + computedConstants[178] = 123.0e99; + computedConstants[179] = 123.456789e99; + computedConstants[181] = 1.0; + computedConstants[182] = 0.0; + computedConstants[183] = 2.71828182845905; + computedConstants[184] = 3.14159265358979; + computedConstants[185] = INFINITY; + computedConstants[186] = NAN; + computedConstants[199] = 1.0; + computedConstants[198] = 3.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = eq(constants[1], constants[0]); + computedConstants[1] = constants[1]/eq(constants[0], constants[0]); + computedConstants[2] = neq(constants[1], constants[0]); + computedConstants[3] = constants[1]/neq(constants[0], constants[2]); + computedConstants[4] = lt(constants[1], constants[0]); + computedConstants[5] = constants[1]/lt(constants[0], constants[2]); + computedConstants[6] = leq(constants[1], constants[0]); + computedConstants[7] = constants[1]/leq(constants[0], constants[2]); + computedConstants[8] = gt(constants[1], constants[0]); + computedConstants[9] = constants[1]/gt(constants[0], constants[2]); + computedConstants[10] = geq(constants[1], constants[0]); + computedConstants[11] = constants[1]/geq(constants[0], constants[2]); + computedConstants[12] = and(constants[1], constants[0]); + computedConstants[13] = and(constants[1], and(constants[0], constants[2])); + computedConstants[14] = and(lt(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[15] = and(constants[1]+constants[0], gt(constants[2], constants[3])); + computedConstants[16] = and(constants[1], gt(constants[0], constants[2])); + computedConstants[17] = and(constants[1]-constants[0], gt(constants[2], constants[3])); + computedConstants[18] = and(-constants[1], gt(constants[0], constants[2])); + computedConstants[19] = and(pow(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[20] = and(pow(constants[1], 1.0/constants[0]), gt(constants[2], constants[3])); + computedConstants[21] = and(lt(constants[1], constants[0]), constants[2]+constants[3]); + computedConstants[22] = and(lt(constants[1], constants[0]), constants[2]); + computedConstants[23] = and(lt(constants[1], constants[0]), constants[2]-constants[3]); + computedConstants[24] = and(lt(constants[1], constants[0]), -constants[2]); + computedConstants[25] = and(lt(constants[1], constants[0]), pow(constants[2], constants[3])); + computedConstants[26] = and(lt(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])); + computedConstants[27] = constants[1]/and(constants[0], constants[2]); + computedConstants[28] = or(constants[1], constants[0]); + computedConstants[29] = or(constants[1], or(constants[0], constants[2])); + computedConstants[30] = or(lt(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[31] = or(constants[1]+constants[0], gt(constants[2], constants[3])); + computedConstants[32] = or(constants[1], gt(constants[0], constants[2])); + computedConstants[33] = or(constants[1]-constants[0], gt(constants[2], constants[3])); + computedConstants[34] = or(-constants[1], gt(constants[0], constants[2])); + computedConstants[35] = or(pow(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[36] = or(pow(constants[1], 1.0/constants[0]), gt(constants[2], constants[3])); + computedConstants[37] = or(lt(constants[1], constants[0]), constants[2]+constants[3]); + computedConstants[38] = or(lt(constants[1], constants[0]), constants[2]); + computedConstants[39] = or(lt(constants[1], constants[0]), constants[2]-constants[3]); + computedConstants[40] = or(lt(constants[1], constants[0]), -constants[2]); + computedConstants[41] = or(lt(constants[1], constants[0]), pow(constants[2], constants[3])); + computedConstants[42] = or(lt(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])); + computedConstants[43] = constants[1]/or(constants[0], constants[2]); + computedConstants[44] = xor(constants[1], constants[0]); + computedConstants[45] = xor(constants[1], xor(constants[0], constants[2])); + computedConstants[46] = xor(lt(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[47] = xor(constants[1]+constants[0], gt(constants[2], constants[3])); + computedConstants[48] = xor(constants[1], gt(constants[0], constants[2])); + computedConstants[49] = xor(constants[1]-constants[0], gt(constants[2], constants[3])); + computedConstants[50] = xor(-constants[1], gt(constants[0], constants[2])); + computedConstants[51] = xor(pow(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[52] = xor(pow(constants[1], 1.0/constants[0]), gt(constants[2], constants[3])); + computedConstants[53] = xor(lt(constants[1], constants[0]), constants[2]+constants[3]); + computedConstants[54] = xor(lt(constants[1], constants[0]), constants[2]); + computedConstants[55] = xor(lt(constants[1], constants[0]), constants[2]-constants[3]); + computedConstants[56] = xor(lt(constants[1], constants[0]), -constants[2]); + computedConstants[57] = xor(lt(constants[1], constants[0]), pow(constants[2], constants[3])); + computedConstants[58] = xor(lt(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])); + computedConstants[59] = constants[1]/xor(constants[0], constants[2]); + computedConstants[60] = not(constants[1]); + computedConstants[61] = constants[1]+constants[0]+constants[2]; + computedConstants[62] = lt(constants[1], constants[0])+gt(constants[2], constants[3]); + computedConstants[63] = constants[1]; + computedConstants[64] = constants[1]-constants[0]; + computedConstants[65] = lt(constants[1], constants[0])-gt(constants[2], constants[3]); + computedConstants[66] = lt(constants[1], constants[0])-(constants[2]+constants[3]); + computedConstants[67] = lt(constants[1], constants[0])-constants[2]; + computedConstants[68] = constants[1]-(-constants[0]); + computedConstants[69] = constants[1]-(-constants[0]*constants[2]); + computedConstants[70] = -constants[1]; + computedConstants[71] = -lt(constants[1], constants[0]); + computedConstants[72] = constants[1]*constants[0]; + computedConstants[73] = constants[1]*constants[0]*constants[2]; + computedConstants[74] = lt(constants[1], constants[0])*gt(constants[2], constants[3]); + computedConstants[75] = (constants[1]+constants[0])*gt(constants[2], constants[3]); + computedConstants[76] = constants[1]*gt(constants[0], constants[2]); + computedConstants[77] = (constants[1]-constants[0])*gt(constants[2], constants[3]); + computedConstants[78] = -constants[1]*gt(constants[0], constants[2]); + computedConstants[79] = lt(constants[1], constants[0])*(constants[2]+constants[3]); + computedConstants[80] = lt(constants[1], constants[0])*constants[2]; + computedConstants[81] = lt(constants[1], constants[0])*(constants[2]-constants[3]); + computedConstants[82] = lt(constants[1], constants[0])*-constants[2]; + computedConstants[83] = constants[1]/constants[0]; + computedConstants[84] = lt(constants[1], constants[0])/gt(constants[3], constants[2]); + computedConstants[85] = (constants[1]+constants[0])/gt(constants[3], constants[2]); + computedConstants[86] = constants[1]/gt(constants[2], constants[0]); + computedConstants[87] = (constants[1]-constants[0])/gt(constants[3], constants[2]); + computedConstants[88] = -constants[1]/gt(constants[2], constants[0]); + computedConstants[89] = lt(constants[1], constants[0])/(constants[2]+constants[3]); + computedConstants[90] = lt(constants[1], constants[0])/constants[2]; + computedConstants[91] = lt(constants[1], constants[0])/(constants[2]-constants[3]); + computedConstants[92] = lt(constants[1], constants[0])/-constants[2]; + computedConstants[93] = lt(constants[1], constants[0])/(constants[2]*constants[3]); + computedConstants[94] = lt(constants[1], constants[0])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[1]); + computedConstants[96] = pow(constants[1], 2.0); + computedConstants[97] = pow(constants[1], 3.0); + computedConstants[98] = pow(constants[1], constants[0]); + computedConstants[99] = pow(leq(constants[1], constants[0]), geq(constants[2], constants[3])); + computedConstants[100] = pow(constants[1]+constants[0], geq(constants[2], constants[3])); + computedConstants[101] = pow(constants[1], geq(constants[0], constants[2])); + computedConstants[102] = pow(constants[1]-constants[0], geq(constants[2], constants[3])); + computedConstants[103] = pow(-constants[1], geq(constants[0], constants[2])); + computedConstants[104] = pow(constants[1]*constants[0], geq(constants[2], constants[3])); + computedConstants[105] = pow(constants[1]/constants[0], geq(constants[2], constants[3])); + computedConstants[106] = pow(leq(constants[1], constants[0]), constants[2]+constants[3]); + computedConstants[107] = pow(leq(constants[1], constants[0]), constants[2]); + computedConstants[108] = pow(leq(constants[1], constants[0]), constants[2]-constants[3]); + computedConstants[109] = pow(leq(constants[1], constants[0]), -constants[2]); + computedConstants[110] = pow(leq(constants[1], constants[0]), constants[2]*constants[3]); + computedConstants[111] = pow(leq(constants[1], constants[0]), constants[2]/constants[3]); + computedConstants[112] = pow(leq(constants[1], constants[0]), pow(constants[2], constants[3])); + computedConstants[113] = pow(leq(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])); + computedConstants[114] = sqrt(constants[1]); + computedConstants[115] = sqrt(constants[1]); + computedConstants[116] = pow(constants[1], 1.0/3.0); + computedConstants[117] = pow(constants[1], 1.0/constants[0]); + computedConstants[118] = pow(lt(constants[1], constants[0]), 1.0/gt(constants[3], constants[2])); + computedConstants[119] = pow(constants[1]+constants[0], 1.0/gt(constants[3], constants[2])); + computedConstants[120] = pow(constants[1], 1.0/gt(constants[2], constants[0])); + computedConstants[121] = pow(constants[1]-constants[0], 1.0/gt(constants[3], constants[2])); + computedConstants[122] = pow(-constants[1], 1.0/gt(constants[2], constants[0])); + computedConstants[123] = pow(constants[1]*constants[0], 1.0/gt(constants[3], constants[2])); + computedConstants[124] = pow(constants[1]/constants[0], 1.0/gt(constants[3], constants[2])); + computedConstants[125] = pow(lt(constants[1], constants[0]), 1.0/(constants[2]+constants[3])); + computedConstants[126] = pow(lt(constants[1], constants[0]), 1.0/constants[2]); + computedConstants[127] = pow(lt(constants[1], constants[0]), 1.0/(constants[2]-constants[3])); + computedConstants[128] = pow(lt(constants[1], constants[0]), 1.0/-constants[2]); + computedConstants[129] = pow(lt(constants[1], constants[0]), 1.0/(constants[2]*constants[3])); + computedConstants[130] = pow(lt(constants[1], constants[0]), 1.0/(constants[2]/constants[3])); + computedConstants[131] = pow(lt(constants[1], constants[0]), 1.0/pow(constants[2], constants[3])); + computedConstants[132] = pow(lt(constants[1], constants[0]), 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[133] = fabs(constants[1]); + computedConstants[134] = exp(constants[1]); + computedConstants[135] = log(constants[1]); + computedConstants[136] = log10(constants[1]); + computedConstants[137] = log(constants[1])/log(2.0); + computedConstants[138] = log10(constants[1]); + computedConstants[139] = log(constants[1])/log(constants[0]); + computedConstants[140] = ceil(constants[1]); + computedConstants[141] = floor(constants[1]); + computedConstants[142] = min(constants[1], constants[0]); + computedConstants[143] = min(constants[1], min(constants[0], constants[2])); + computedConstants[144] = max(constants[1], constants[0]); + computedConstants[145] = max(constants[1], max(constants[0], constants[2])); + computedConstants[146] = fmod(constants[1], constants[0]); + computedConstants[147] = sin(constants[1]); + computedConstants[148] = cos(constants[1]); + computedConstants[149] = tan(constants[1]); + computedConstants[150] = sec(constants[1]); + computedConstants[151] = csc(constants[1]); + computedConstants[152] = cot(constants[1]); + computedConstants[153] = sinh(constants[1]); + computedConstants[154] = cosh(constants[1]); + computedConstants[155] = tanh(constants[1]); + computedConstants[156] = sech(constants[1]); + computedConstants[157] = csch(constants[1]); + computedConstants[158] = coth(constants[1]); + computedConstants[159] = asin(constants[1]); + computedConstants[160] = acos(constants[1]); + computedConstants[161] = atan(constants[1]); + computedConstants[162] = asec(constants[1]); + computedConstants[163] = acsc(constants[1]); + computedConstants[164] = acot(constants[1]); + computedConstants[165] = asinh(constants[1]); + computedConstants[166] = acosh(constants[1]); + computedConstants[167] = atanh(constants[1]/2.0); + computedConstants[168] = asech(constants[1]); + computedConstants[169] = acsch(constants[1]); + computedConstants[170] = acoth(2.0*constants[1]); + computedConstants[171] = (gt(constants[1], constants[0]))?constants[1]:NAN; + computedConstants[172] = (gt(constants[1], constants[0]))?constants[1]:constants[2]; + computedConstants[173] = (gt(constants[1], constants[0]))?constants[1]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:NAN; + computedConstants[174] = (gt(constants[1], constants[0]))?constants[1]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:constants[6]; + computedConstants[175] = 123.0+((gt(constants[1], constants[0]))?constants[1]:NAN); + computedConstants[180] = constants[1]; + computedConstants[187] = and(constants[1], constants[0])+((gt(constants[2], constants[3]))?constants[0]:NAN)+constants[4]+and(constants[5], constants[6]); + computedConstants[188] = and(constants[1], constants[0])-(((gt(constants[2], constants[3]))?constants[0]:NAN)-(constants[4]-((gt(constants[2], constants[3]))?constants[0]:NAN)))-and(constants[5], constants[6]); + computedConstants[189] = and(constants[1], constants[0])*((gt(constants[2], constants[3]))?constants[0]:NAN)*constants[4]*((gt(constants[2], constants[3]))?constants[0]:NAN)*and(constants[5], constants[6]); + computedConstants[190] = and(constants[1], constants[0])/(((gt(constants[2], constants[3]))?constants[0]:NAN)/(constants[4]/((gt(constants[2], constants[3]))?constants[0]:NAN))); + computedConstants[191] = and(or(constants[1], constants[0]), and(xor(constants[1], constants[0]), and((gt(constants[2], constants[3]))?constants[0]:NAN, and(and(and(constants[4], (gt(constants[2], constants[3]))?constants[0]:NAN), xor(constants[1], constants[0])), or(constants[1], constants[0]))))); + computedConstants[192] = or(and(constants[1], constants[0]), or(xor(constants[1], constants[0]), or((gt(constants[2], constants[3]))?constants[0]:NAN, or(or(or(constants[4], (gt(constants[2], constants[3]))?constants[0]:NAN), xor(constants[1], constants[0])), and(constants[1], constants[0]))))); + computedConstants[193] = xor(and(constants[1], constants[0]), xor(or(constants[1], constants[0]), xor((gt(constants[2], constants[3]))?constants[0]:NAN, xor(xor(xor(constants[4], (gt(constants[2], constants[3]))?constants[0]:NAN), or(constants[1], constants[0])), and(constants[1], constants[0]))))); + computedConstants[194] = pow(and(constants[1], constants[0]), pow((gt(constants[2], constants[3]))?constants[0]:NAN, pow(pow(constants[4], (gt(constants[2], constants[3]))?constants[0]:NAN), and(constants[1], constants[0])))); + computedConstants[195] = pow(pow(pow(and(constants[1], constants[0]), 1.0/pow((gt(constants[2], constants[3]))?constants[0]:NAN, 1.0/constants[4])), 1.0/((gt(constants[2], constants[3]))?constants[0]:NAN)), 1.0/and(constants[1], constants[0])); + computedConstants[196] = -and(constants[1], constants[0])-((gt(constants[2], constants[3]))?constants[0]:NAN); + computedConstants[197] = computedConstants[199]+computedConstants[198]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + rates[0] = 1.0; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); +} diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation_windows.out similarity index 97% rename from tests/resources/coverage/generator/model.implementation.out rename to tests/resources/coverage/generator/model.implementation_windows.out index 16cc995497..dfa3a57491 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation_windows.out @@ -167,8 +167,8 @@ void objectiveFunction0(double *u, double *f, void *data) algebraicVariables[0] = u[0]; algebraicVariables[1] = u[1]; - f[0] = algebraicVariables[1]+algebraicVariables[0]+states[0]-0.0; - f[1] = algebraicVariables[1]-algebraicVariables[0]-(computedConstants[198]+computedConstants[197]); + f[0] = constants[1]+sin(algebraicVariables[1])+computedConstants[197]+states[0]+sin(algebraicVariables[0])-1.0; + f[1] = sin(algebraicVariables[1])-computedConstants[197]-computedConstants[198]-computedConstants[199]-sin(algebraicVariables[0])-0.5; } void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) @@ -205,10 +205,10 @@ void initialiseArrays(double *states, double *rates, double *constants, double * computedConstants[184] = 3.14159265358979; computedConstants[185] = INFINITY; computedConstants[186] = NAN; - computedConstants[198] = 1.0; - computedConstants[197] = 3.0; - algebraicVariables[0] = 2.0; - algebraicVariables[1] = 1.0; + computedConstants[199] = 1.0; + computedConstants[198] = 3.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; } void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) @@ -399,7 +399,8 @@ void computeComputedConstants(double voi, double *states, double *rates, double computedConstants[193] = xor(and(constants[1], constants[0]), xor(or(constants[1], constants[0]), xor((gt(constants[2], constants[3]))?constants[0]:NAN, xor(xor(xor(constants[4], (gt(constants[2], constants[3]))?constants[0]:NAN), or(constants[1], constants[0])), and(constants[1], constants[0]))))); computedConstants[194] = pow(and(constants[1], constants[0]), pow((gt(constants[2], constants[3]))?constants[0]:NAN, pow(pow(constants[4], (gt(constants[2], constants[3]))?constants[0]:NAN), and(constants[1], constants[0])))); computedConstants[195] = pow(pow(pow(and(constants[1], constants[0]), 1.0/pow((gt(constants[2], constants[3]))?constants[0]:NAN, 1.0/constants[4])), 1.0/((gt(constants[2], constants[3]))?constants[0]:NAN)), 1.0/and(constants[1], constants[0])); - computedConstants[196] = -and(constants[1], constants[0])+-((gt(constants[2], constants[3]))?constants[0]:NAN); + computedConstants[196] = -and(constants[1], constants[0])-((gt(constants[2], constants[3]))?constants[0]:NAN); + computedConstants[197] = computedConstants[199]+computedConstants[198]; } void computeRates(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_linux.c b/tests/resources/coverage/generator/model.modified.profile_linux.c new file mode 100644 index 0000000000..f7502dc26d --- /dev/null +++ b/tests/resources/coverage/generator/model.modified.profile_linux.c @@ -0,0 +1,657 @@ +/* The content of this file was generated using a modified C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0.post0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 1; +const size_t CONSTANT_COUNT = 7; +const size_t COMPUTED_CONSTANT_COUNT = 200; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"t", "second", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"n", "dimensionless", "my_component"}, + {"m", "dimensionless", "my_component"}, + {"o", "dimensionless", "my_component"}, + {"p", "dimensionless", "my_component"}, + {"q", "dimensionless", "my_component"}, + {"r", "dimensionless", "my_component"}, + {"s", "dimensionless", "my_component"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"eqnEq", "dimensionless", "my_component"}, + {"eqnEqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnNeq", "dimensionless", "my_component"}, + {"eqnNeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnLt", "dimensionless", "my_component"}, + {"eqnLtCoverageParentheses", "dimensionless", "my_component"}, + {"eqnLeq", "dimensionless", "my_component"}, + {"eqnLeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnGt", "dimensionless", "my_component"}, + {"eqnGtCoverageParentheses", "dimensionless", "my_component"}, + {"eqnGeq", "dimensionless", "my_component"}, + {"eqnGeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnAnd", "dimensionless", "my_component"}, + {"eqnAndMultiple", "dimensionless", "my_component"}, + {"eqnAndParentheses", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnAndCoverageParentheses", "dimensionless", "my_component"}, + {"eqnOr", "dimensionless", "my_component"}, + {"eqnOrMultiple", "dimensionless", "my_component"}, + {"eqnOrParentheses", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnOrCoverageParentheses", "dimensionless", "my_component"}, + {"eqnXor", "dimensionless", "my_component"}, + {"eqnXorMultiple", "dimensionless", "my_component"}, + {"eqnXorParentheses", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnXorCoverageParentheses", "dimensionless", "my_component"}, + {"eqnNot", "dimensionless", "my_component"}, + {"eqnPlusMultiple", "dimensionless", "my_component"}, + {"eqnPlusParentheses", "dimensionless", "my_component"}, + {"eqnPlusUnary", "dimensionless", "my_component"}, + {"eqnMinus", "dimensionless", "my_component"}, + {"eqnMinusParentheses", "dimensionless", "my_component"}, + {"eqnMinusParenthesesPlusWith", "dimensionless", "my_component"}, + {"eqnMinusParenthesesPlusWithout", "dimensionless", "my_component"}, + {"eqnMinusParenthesesDirectUnaryMinus", "dimensionless", "my_component"}, + {"eqnMinusParenthesesIndirectUnaryMinus", "dimensionless", "my_component"}, + {"eqnMinusUnary", "dimensionless", "my_component"}, + {"eqnMinusUnaryParentheses", "dimensionless", "my_component"}, + {"eqnTimes", "dimensionless", "my_component"}, + {"eqnTimesMultiple", "dimensionless", "my_component"}, + {"eqnTimesParentheses", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnDivide", "dimensionless", "my_component"}, + {"eqnDivideParentheses", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnPowerSqrt", "dimensionless", "my_component"}, + {"eqnPowerSqr", "dimensionless", "my_component"}, + {"eqnPowerCube", "dimensionless", "my_component"}, + {"eqnPowerCi", "dimensionless", "my_component"}, + {"eqnPowerParentheses", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftTimes", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftDivide", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnRootSqrt", "dimensionless", "my_component"}, + {"eqnRootSqrtOther", "dimensionless", "my_component"}, + {"eqnRootCube", "dimensionless", "my_component"}, + {"eqnRootCi", "dimensionless", "my_component"}, + {"eqnRootParentheses", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftTimes", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftDivide", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnAbs", "dimensionless", "my_component"}, + {"eqnExp", "dimensionless", "my_component"}, + {"eqnLn", "dimensionless", "my_component"}, + {"eqnLog", "dimensionless", "my_component"}, + {"eqnLog2", "dimensionless", "my_component"}, + {"eqnLog10", "dimensionless", "my_component"}, + {"eqnLogCi", "dimensionless", "my_component"}, + {"eqnCeiling", "dimensionless", "my_component"}, + {"eqnFloor", "dimensionless", "my_component"}, + {"eqnMin", "dimensionless", "my_component"}, + {"eqnMinMultiple", "dimensionless", "my_component"}, + {"eqnMax", "dimensionless", "my_component"}, + {"eqnMaxMultiple", "dimensionless", "my_component"}, + {"eqnRem", "dimensionless", "my_component"}, + {"eqnSin", "dimensionless", "my_component"}, + {"eqnCos", "dimensionless", "my_component"}, + {"eqnTan", "dimensionless", "my_component"}, + {"eqnSec", "dimensionless", "my_component"}, + {"eqnCsc", "dimensionless", "my_component"}, + {"eqnCot", "dimensionless", "my_component"}, + {"eqnSinh", "dimensionless", "my_component"}, + {"eqnCosh", "dimensionless", "my_component"}, + {"eqnTanh", "dimensionless", "my_component"}, + {"eqnSech", "dimensionless", "my_component"}, + {"eqnCsch", "dimensionless", "my_component"}, + {"eqnCoth", "dimensionless", "my_component"}, + {"eqnArcsin", "dimensionless", "my_component"}, + {"eqnArccos", "dimensionless", "my_component"}, + {"eqnArctan", "dimensionless", "my_component"}, + {"eqnArcsec", "dimensionless", "my_component"}, + {"eqnArccsc", "dimensionless", "my_component"}, + {"eqnArccot", "dimensionless", "my_component"}, + {"eqnArcsinh", "dimensionless", "my_component"}, + {"eqnArccosh", "dimensionless", "my_component"}, + {"eqnArctanh", "dimensionless", "my_component"}, + {"eqnArcsech", "dimensionless", "my_component"}, + {"eqnArccsch", "dimensionless", "my_component"}, + {"eqnArccoth", "dimensionless", "my_component"}, + {"eqnPiecewisePiece", "dimensionless", "my_component"}, + {"eqnPiecewisePieceOtherwise", "dimensionless", "my_component"}, + {"eqnPiecewisePiecePiecePiece", "dimensionless", "my_component"}, + {"eqnPiecewisePiecePiecePieceOtherwise", "dimensionless", "my_component"}, + {"eqnWithPiecewise", "dimensionless", "my_component"}, + {"eqnCnInteger", "dimensionless", "my_component"}, + {"eqnCnDouble", "dimensionless", "my_component"}, + {"eqnCnIntegerWithExponent", "dimensionless", "my_component"}, + {"eqnCnDoubleWithExponent", "dimensionless", "my_component"}, + {"eqnCi", "dimensionless", "my_component"}, + {"eqnTrue", "dimensionless", "my_component"}, + {"eqnFalse", "dimensionless", "my_component"}, + {"eqnExponentiale", "dimensionless", "my_component"}, + {"eqnPi", "dimensionless", "my_component"}, + {"eqnInfinity", "dimensionless", "my_component"}, + {"eqnNotanumber", "dimensionless", "my_component"}, + {"eqnCoverageForPlusOperator", "dimensionless", "my_component"}, + {"eqnCoverageForMinusOperator", "dimensionless", "my_component"}, + {"eqnCoverageForTimesOperator", "dimensionless", "my_component"}, + {"eqnCoverageForDivideOperator", "dimensionless", "my_component"}, + {"eqnCoverageForAndOperator", "dimensionless", "my_component"}, + {"eqnCoverageForOrOperator", "dimensionless", "my_component"}, + {"eqnCoverageForXorOperator", "dimensionless", "my_component"}, + {"eqnCoverageForPowerOperator", "dimensionless", "my_component"}, + {"eqnCoverageForRootOperator", "dimensionless", "my_component"}, + {"eqnCoverageForMinusUnary", "dimensionless", "my_component"}, + {"eqnComputedConstant3", "dimensionless", "my_component"}, + {"eqnComputedConstant2", "dimensionless", "my_component"}, + {"eqnComputedConstant1", "dimensionless", "my_component"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"eqnNlaVariable2", "dimensionless", "my_component"}, + {"eqnNlaVariable1", "dimensionless", "my_component"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"eqnPlus", "dimensionless", "my_component"} +}; + +double xor(double x, double y) +{ + return (x != 0.0) ^ (y != 0.0); +} + +double min(double x, double y) +{ + return (x < y)?x:y; +} + +double max(double x, double y) +{ + return (x > y)?x:y; +} + +double sec(double x) +{ + return 1.0/cos(x); +} + +double csc(double x) +{ + return 1.0/sin(x); +} + +double cot(double x) +{ + return 1.0/tan(x); +} + +double sech(double x) +{ + return 1.0/cosh(x); +} + +double csch(double x) +{ + return 1.0/sinh(x); +} + +double coth(double x) +{ + return 1.0/tanh(x); +} + +double asec(double x) +{ + return acos(1.0/x); +} + +double acsc(double x) +{ + return asin(1.0/x); +} + +double acot(double x) +{ + return atan(1.0/x); +} + +double asech(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX-1.0)); +} + +double acsch(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX+1.0)); +} + +double acoth(double x) +{ + double oneOverX = 1.0/x; + + return 0.5*log((1.0+oneOverX)/(1.0-oneOverX)); +} + +double * createStatesVector() +{ + 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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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; + double *externalVariables; +} 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; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; + + f[0] = sin(algebraicVariables[1])+sin(algebraicVariables[0])+states[0]+computedConstants[197]+constants[1]-1.0; + f[1] = -sin(algebraicVariables[0])+sin(algebraicVariables[1])-computedConstants[199]-computedConstants[197]-computedConstants[198]-0.5; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; + double u[2]; + + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; + + nlaSolve(objectiveFunction0, u, 2, &rfi); + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + constants[0] = 1.23; + constants[1] = 123.0; + constants[2] = 1.0e1; + constants[3] = 1.23e1; + constants[4] = 1.0E1; + constants[5] = 1.23E1; + constants[6] = 7.0; + computedConstants[176] = 123.0; + computedConstants[177] = 123.456789; + computedConstants[178] = 123.0e99; + computedConstants[179] = 123.456789e99; + computedConstants[181] = 1.0; + computedConstants[182] = 0.0; + computedConstants[183] = 2.71828182845905; + computedConstants[184] = 3.14159265358979; + computedConstants[185] = INFINITY; + computedConstants[186] = NAN; + computedConstants[199] = 1.0; + computedConstants[198] = 3.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[1] == constants[0]; + computedConstants[1] = constants[1]/(constants[0] == constants[0]); + computedConstants[2] = constants[1] != constants[0]; + computedConstants[3] = constants[1]/(constants[0] != constants[2]); + computedConstants[4] = constants[1] < constants[0]; + computedConstants[5] = constants[1]/(constants[0] < constants[2]); + computedConstants[6] = constants[1] <= constants[0]; + computedConstants[7] = constants[1]/(constants[0] <= constants[2]); + computedConstants[8] = constants[1] > constants[0]; + computedConstants[9] = constants[1]/(constants[0] > constants[2]); + computedConstants[10] = constants[1] >= constants[0]; + computedConstants[11] = constants[1]/(constants[0] >= constants[2]); + computedConstants[12] = constants[1] && constants[0]; + computedConstants[13] = constants[1] && constants[0] && constants[2]; + computedConstants[14] = (constants[1] < constants[0]) && (constants[2] > constants[3]); + computedConstants[15] = (constants[1]+constants[0]) && (constants[2] > constants[3]); + computedConstants[16] = constants[1] && (constants[0] > constants[2]); + computedConstants[17] = (constants[1]-constants[0]) && (constants[2] > constants[3]); + computedConstants[18] = -constants[1] && (constants[0] > constants[2]); + computedConstants[19] = pow(constants[1], constants[0]) && (constants[2] > constants[3]); + computedConstants[20] = pow(constants[1], 1.0/constants[0]) && (constants[2] > constants[3]); + computedConstants[21] = (constants[1] < constants[0]) && (constants[2]+constants[3]); + computedConstants[22] = (constants[1] < constants[0]) && constants[2]; + computedConstants[23] = (constants[1] < constants[0]) && (constants[2]-constants[3]); + computedConstants[24] = (constants[1] < constants[0]) && -constants[2]; + computedConstants[25] = (constants[1] < constants[0]) && pow(constants[2], constants[3]); + computedConstants[26] = (constants[1] < constants[0]) && pow(constants[2], 1.0/constants[3]); + computedConstants[27] = constants[1]/(constants[0] && constants[2]); + computedConstants[28] = constants[1] || constants[0]; + computedConstants[29] = constants[1] || constants[0] || constants[2]; + computedConstants[30] = (constants[1] < constants[0]) || (constants[2] > constants[3]); + computedConstants[31] = (constants[1]+constants[0]) || (constants[2] > constants[3]); + computedConstants[32] = constants[1] || (constants[0] > constants[2]); + computedConstants[33] = (constants[1]-constants[0]) || (constants[2] > constants[3]); + computedConstants[34] = -constants[1] || (constants[0] > constants[2]); + computedConstants[35] = pow(constants[1], constants[0]) || (constants[2] > constants[3]); + computedConstants[36] = pow(constants[1], 1.0/constants[0]) || (constants[2] > constants[3]); + computedConstants[37] = (constants[1] < constants[0]) || (constants[2]+constants[3]); + computedConstants[38] = (constants[1] < constants[0]) || constants[2]; + computedConstants[39] = (constants[1] < constants[0]) || (constants[2]-constants[3]); + computedConstants[40] = (constants[1] < constants[0]) || -constants[2]; + computedConstants[41] = (constants[1] < constants[0]) || pow(constants[2], constants[3]); + computedConstants[42] = (constants[1] < constants[0]) || pow(constants[2], 1.0/constants[3]); + computedConstants[43] = constants[1]/(constants[0] || constants[2]); + computedConstants[44] = xor(constants[1], constants[0]); + computedConstants[45] = xor(constants[1], xor(constants[0], constants[2])); + computedConstants[46] = xor(constants[1] < constants[0], constants[2] > constants[3]); + computedConstants[47] = xor(constants[1]+constants[0], constants[2] > constants[3]); + computedConstants[48] = xor(constants[1], constants[0] > constants[2]); + computedConstants[49] = xor(constants[1]-constants[0], constants[2] > constants[3]); + computedConstants[50] = xor(-constants[1], constants[0] > constants[2]); + computedConstants[51] = xor(pow(constants[1], constants[0]), constants[2] > constants[3]); + computedConstants[52] = xor(pow(constants[1], 1.0/constants[0]), constants[2] > constants[3]); + computedConstants[53] = xor(constants[1] < constants[0], constants[2]+constants[3]); + computedConstants[54] = xor(constants[1] < constants[0], constants[2]); + computedConstants[55] = xor(constants[1] < constants[0], constants[2]-constants[3]); + computedConstants[56] = xor(constants[1] < constants[0], -constants[2]); + computedConstants[57] = xor(constants[1] < constants[0], pow(constants[2], constants[3])); + computedConstants[58] = xor(constants[1] < constants[0], pow(constants[2], 1.0/constants[3])); + computedConstants[59] = constants[1]/xor(constants[0], constants[2]); + computedConstants[60] = !constants[1]; + computedConstants[61] = constants[1]+constants[0]+constants[2]; + computedConstants[62] = (constants[1] < constants[0])+(constants[2] > constants[3]); + computedConstants[63] = constants[1]; + computedConstants[64] = constants[1]-constants[0]; + computedConstants[65] = (constants[1] < constants[0])-(constants[2] > constants[3]); + computedConstants[66] = (constants[1] < constants[0])-(constants[2]+constants[3]); + computedConstants[67] = (constants[1] < constants[0])-constants[2]; + computedConstants[68] = constants[1]-(-constants[0]); + computedConstants[69] = constants[1]-(-constants[0]*constants[2]); + computedConstants[70] = -constants[1]; + computedConstants[71] = -(constants[1] < constants[0]); + computedConstants[72] = constants[1]*constants[0]; + computedConstants[73] = constants[1]*constants[0]*constants[2]; + computedConstants[74] = (constants[1] < constants[0])*(constants[2] > constants[3]); + computedConstants[75] = (constants[1]+constants[0])*(constants[2] > constants[3]); + computedConstants[76] = constants[1]*(constants[0] > constants[2]); + computedConstants[77] = (constants[1]-constants[0])*(constants[2] > constants[3]); + computedConstants[78] = -constants[1]*(constants[0] > constants[2]); + computedConstants[79] = (constants[1] < constants[0])*(constants[2]+constants[3]); + computedConstants[80] = (constants[1] < constants[0])*constants[2]; + computedConstants[81] = (constants[1] < constants[0])*(constants[2]-constants[3]); + computedConstants[82] = (constants[1] < constants[0])*-constants[2]; + computedConstants[83] = constants[1]/constants[0]; + computedConstants[84] = (constants[1] < constants[0])/(constants[3] > constants[2]); + computedConstants[85] = (constants[1]+constants[0])/(constants[3] > constants[2]); + computedConstants[86] = constants[1]/(constants[2] > constants[0]); + computedConstants[87] = (constants[1]-constants[0])/(constants[3] > constants[2]); + computedConstants[88] = -constants[1]/(constants[2] > constants[0]); + computedConstants[89] = (constants[1] < constants[0])/(constants[2]+constants[3]); + computedConstants[90] = (constants[1] < constants[0])/constants[2]; + computedConstants[91] = (constants[1] < constants[0])/(constants[2]-constants[3]); + computedConstants[92] = (constants[1] < constants[0])/-constants[2]; + computedConstants[93] = (constants[1] < constants[0])/(constants[2]*constants[3]); + computedConstants[94] = (constants[1] < constants[0])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[1]); + computedConstants[96] = pow(constants[1], 2.0); + computedConstants[97] = pow(constants[1], 3.0); + computedConstants[98] = pow(constants[1], constants[0]); + computedConstants[99] = pow(constants[1] <= constants[0], constants[2] >= constants[3]); + computedConstants[100] = pow(constants[1]+constants[0], constants[2] >= constants[3]); + computedConstants[101] = pow(constants[1], constants[0] >= constants[2]); + computedConstants[102] = pow(constants[1]-constants[0], constants[2] >= constants[3]); + computedConstants[103] = pow(-constants[1], constants[0] >= constants[2]); + computedConstants[104] = pow(constants[1]*constants[0], constants[2] >= constants[3]); + computedConstants[105] = pow(constants[1]/constants[0], constants[2] >= constants[3]); + computedConstants[106] = pow(constants[1] <= constants[0], constants[2]+constants[3]); + computedConstants[107] = pow(constants[1] <= constants[0], constants[2]); + computedConstants[108] = pow(constants[1] <= constants[0], constants[2]-constants[3]); + computedConstants[109] = pow(constants[1] <= constants[0], -constants[2]); + computedConstants[110] = pow(constants[1] <= constants[0], constants[2]*constants[3]); + computedConstants[111] = pow(constants[1] <= constants[0], constants[2]/constants[3]); + computedConstants[112] = pow(constants[1] <= constants[0], pow(constants[2], constants[3])); + computedConstants[113] = pow(constants[1] <= constants[0], pow(constants[2], 1.0/constants[3])); + computedConstants[114] = sqrt(constants[1]); + computedConstants[115] = sqrt(constants[1]); + computedConstants[116] = pow(constants[1], 1.0/3.0); + computedConstants[117] = pow(constants[1], 1.0/constants[0]); + computedConstants[118] = pow(constants[1] < constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[119] = pow(constants[1]+constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[120] = pow(constants[1], 1.0/(constants[2] > constants[0])); + computedConstants[121] = pow(constants[1]-constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[122] = pow(-constants[1], 1.0/(constants[2] > constants[0])); + computedConstants[123] = pow(constants[1]*constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[124] = pow(constants[1]/constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[125] = pow(constants[1] < constants[0], 1.0/(constants[2]+constants[3])); + computedConstants[126] = pow(constants[1] < constants[0], 1.0/constants[2]); + computedConstants[127] = pow(constants[1] < constants[0], 1.0/(constants[2]-constants[3])); + computedConstants[128] = pow(constants[1] < constants[0], 1.0/-constants[2]); + computedConstants[129] = pow(constants[1] < constants[0], 1.0/(constants[2]*constants[3])); + computedConstants[130] = pow(constants[1] < constants[0], 1.0/(constants[2]/constants[3])); + computedConstants[131] = pow(constants[1] < constants[0], 1.0/pow(constants[2], constants[3])); + computedConstants[132] = pow(constants[1] < constants[0], 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[133] = fabs(constants[1]); + computedConstants[134] = exp(constants[1]); + computedConstants[135] = log(constants[1]); + computedConstants[136] = log10(constants[1]); + computedConstants[137] = log(constants[1])/log(2.0); + computedConstants[138] = log10(constants[1]); + computedConstants[139] = log(constants[1])/log(constants[0]); + computedConstants[140] = ceil(constants[1]); + computedConstants[141] = floor(constants[1]); + computedConstants[142] = min(constants[1], constants[0]); + computedConstants[143] = min(constants[1], min(constants[0], constants[2])); + computedConstants[144] = max(constants[1], constants[0]); + computedConstants[145] = max(constants[1], max(constants[0], constants[2])); + computedConstants[146] = fmod(constants[1], constants[0]); + computedConstants[147] = sin(constants[1]); + computedConstants[148] = cos(constants[1]); + computedConstants[149] = tan(constants[1]); + computedConstants[150] = sec(constants[1]); + computedConstants[151] = csc(constants[1]); + computedConstants[152] = cot(constants[1]); + computedConstants[153] = sinh(constants[1]); + computedConstants[154] = cosh(constants[1]); + computedConstants[155] = tanh(constants[1]); + computedConstants[156] = sech(constants[1]); + computedConstants[157] = csch(constants[1]); + computedConstants[158] = coth(constants[1]); + computedConstants[159] = asin(constants[1]); + computedConstants[160] = acos(constants[1]); + computedConstants[161] = atan(constants[1]); + computedConstants[162] = asec(constants[1]); + computedConstants[163] = acsc(constants[1]); + computedConstants[164] = acot(constants[1]); + computedConstants[165] = asinh(constants[1]); + computedConstants[166] = acosh(constants[1]); + computedConstants[167] = atanh(constants[1]/2.0); + computedConstants[168] = asech(constants[1]); + computedConstants[169] = acsch(constants[1]); + computedConstants[170] = acoth(2.0*constants[1]); + computedConstants[171] = (constants[1] > constants[0])?constants[1]:NAN; + computedConstants[172] = (constants[1] > constants[0])?constants[1]:constants[2]; + computedConstants[173] = (constants[1] > constants[0])?constants[1]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; + computedConstants[174] = (constants[1] > constants[0])?constants[1]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; + computedConstants[175] = 123.0+((constants[1] > constants[0])?constants[1]:NAN); + computedConstants[180] = constants[1]; + computedConstants[187] = (constants[1] && constants[0])+((constants[2] > constants[3])?constants[0]:NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[188] = (constants[1] && constants[0])-(((constants[2] > constants[3])?constants[0]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[0]:NAN)))-(constants[5] && constants[6]); + computedConstants[189] = (constants[1] && constants[0])*((constants[2] > constants[3])?constants[0]:NAN)*constants[4]*((constants[2] > constants[3])?constants[0]:NAN)*(constants[5] && constants[6]); + computedConstants[190] = (constants[1] && constants[0])/(((constants[2] > constants[3])?constants[0]:NAN)/(constants[4]/((constants[2] > constants[3])?constants[0]:NAN))); + computedConstants[191] = (constants[1] || constants[0]) && xor(constants[1], constants[0]) && ((constants[2] > constants[3])?constants[0]:NAN) && constants[4] && ((constants[2] > constants[3])?constants[0]:NAN) && xor(constants[1], constants[0]) && (constants[1] || constants[0]); + computedConstants[192] = (constants[1] && constants[0]) || xor(constants[1], constants[0]) || ((constants[2] > constants[3])?constants[0]:NAN) || constants[4] || ((constants[2] > constants[3])?constants[0]:NAN) || xor(constants[1], constants[0]) || (constants[1] && constants[0]); + computedConstants[193] = xor(constants[1] && constants[0], xor(constants[1] || constants[0], xor((constants[2] > constants[3])?constants[0]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] || constants[0]), constants[1] && constants[0])))); + computedConstants[194] = pow(constants[1] && constants[0], pow((constants[2] > constants[3])?constants[0]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] && constants[0]))); + computedConstants[195] = pow(pow(pow(constants[1] && constants[0], 1.0/pow((constants[2] > constants[3])?constants[0]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[0]:NAN)), 1.0/(constants[1] && constants[0])); + computedConstants[196] = -(constants[1] && constants[0])-((constants[2] > constants[3])?constants[0]:NAN); + computedConstants[197] = computedConstants[199]+computedConstants[198]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + rates[0] = 1.0; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); +} diff --git a/tests/resources/coverage/generator/model.modified.profile_linux.py b/tests/resources/coverage/generator/model.modified.profile_linux.py new file mode 100644 index 0000000000..e8af253ba2 --- /dev/null +++ b/tests/resources/coverage/generator/model.modified.profile_linux.py @@ -0,0 +1,620 @@ +# The content of this file was generated using a modified Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0.post0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 1 +CONSTANT_COUNT = 7 +COMPUTED_CONSTANT_COUNT = 200 +ALGEBRAIC_VARIABLE_COUNT = 2 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} + +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ + {"name": "n", "units": "dimensionless", "component": "my_component"}, + {"name": "m", "units": "dimensionless", "component": "my_component"}, + {"name": "o", "units": "dimensionless", "component": "my_component"}, + {"name": "p", "units": "dimensionless", "component": "my_component"}, + {"name": "q", "units": "dimensionless", "component": "my_component"}, + {"name": "r", "units": "dimensionless", "component": "my_component"}, + {"name": "s", "units": "dimensionless", "component": "my_component"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "eqnEq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnEqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLtCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGtCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAnd", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOr", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXor", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesDirectUnaryMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesIndirectUnaryMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusUnaryParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerSqrt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerSqr", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerCube", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootSqrt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootSqrtOther", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootCube", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAbs", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnExp", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLn", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog10", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLogCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCeiling", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnFloor", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMax", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMaxMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRem", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCos", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTan", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSec", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCsc", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSinh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCosh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTanh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSech", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCsch", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoth", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccos", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArctan", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsec", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccsc", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsinh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccosh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArctanh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsech", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccsch", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccoth", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiece", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePieceOtherwise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiecePiecePiece", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiecePiecePieceOtherwise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnWithPiecewise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnInteger", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnDouble", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnIntegerWithExponent", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnDoubleWithExponent", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTrue", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnFalse", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnExponentiale", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnInfinity", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNotanumber", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForPlusOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForMinusOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForTimesOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForDivideOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForAndOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForOrOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForXorOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForPowerOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant3", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "eqnPlus", "units": "dimensionless", "component": "my_component"} +] + + +def eq_func(x, y): + return 1.0 if x == y else 0.0 + + +def neq_func(x, y): + return 1.0 if x != y else 0.0 + + +def lt_func(x, y): + return 1.0 if x < y else 0.0 + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def gt_func(x, y): + return 1.0 if x > y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def or_func(x, y): + return 1.0 if bool(x) | bool(y) else 0.0 + + +def xor_func(x, y): + return 1.0 if bool(x) ^ bool(y) else 0.0 + + +def not_func(x): + return 1.0 if not bool(x) else 0.0 + + +def min(x, y): + return x if x < y else y + + +def max(x, y): + return x if x > y else y + + +def sec(x): + return 1.0/cos(x) + + +def csc(x): + return 1.0/sin(x) + + +def cot(x): + return 1.0/tan(x) + + +def sech(x): + return 1.0/cosh(x) + + +def csch(x): + return 1.0/sinh(x) + + +def coth(x): + return 1.0/tanh(x) + + +def asec(x): + return acos(1.0/x) + + +def acsc(x): + return asin(1.0/x) + + +def acot(x): + return atan(1.0/x) + + +def asech(x): + one_over_x = 1.0/x + + return log(one_over_x+sqrt(one_over_x*one_over_x-1.0)) + + +def acsch(x): + one_over_x = 1.0/x + + return log(one_over_x+sqrt(one_over_x*one_over_x+1.0)) + + +def acoth(x): + one_over_x = 1.0/x + + return 0.5*log((1.0+one_over_x)/(1.0-one_over_x)) + + +def create_states_vector(): + 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 create_external_variables_array(): + return [nan]*EXTERNAL_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] + external_variables = data[6] + + algebraic_variables[0] = u[0] + algebraic_variables[1] = u[1] + + f[0] = sin(algebraic_variables[1])+sin(algebraic_variables[0])+states[0]+computed_constants[197]+constants[1]-1.0 + f[1] = -sin(algebraic_variables[0])+sin(algebraic_variables[1])-computed_constants[199]-computed_constants[197]-computed_constants[198]-0.5 + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): + u = [nan]*2 + + u[0] = algebraic_variables[0] + u[1] = algebraic_variables[1] + + u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) + + algebraic_variables[0] = u[0] + algebraic_variables[1] = u[1] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + constants[0] = 1.23 + constants[1] = 123.0 + constants[2] = 1.0e1 + constants[3] = 1.23e1 + constants[4] = 1.0E1 + constants[5] = 1.23E1 + constants[6] = 7.0 + computed_constants[176] = 123.0 + computed_constants[177] = 123.456789 + computed_constants[178] = 123.0e99 + computed_constants[179] = 123.456789e99 + computed_constants[181] = 1.0 + computed_constants[182] = 0.0 + computed_constants[183] = 2.71828182845905 + computed_constants[184] = 3.14159265358979 + computed_constants[185] = inf + computed_constants[186] = nan + computed_constants[199] = 1.0 + computed_constants[198] = 3.0 + algebraic_variables[0] = 0.0 + algebraic_variables[1] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = eq_func(constants[1], constants[0]) + computed_constants[1] = constants[1]/eq_func(constants[0], constants[0]) + computed_constants[2] = neq_func(constants[1], constants[0]) + computed_constants[3] = constants[1]/neq_func(constants[0], constants[2]) + computed_constants[4] = lt_func(constants[1], constants[0]) + computed_constants[5] = constants[1]/lt_func(constants[0], constants[2]) + computed_constants[6] = leq_func(constants[1], constants[0]) + computed_constants[7] = constants[1]/leq_func(constants[0], constants[2]) + computed_constants[8] = gt_func(constants[1], constants[0]) + computed_constants[9] = constants[1]/gt_func(constants[0], constants[2]) + computed_constants[10] = geq_func(constants[1], constants[0]) + computed_constants[11] = constants[1]/geq_func(constants[0], constants[2]) + computed_constants[12] = and_func(constants[1], constants[0]) + computed_constants[13] = and_func(constants[1], and_func(constants[0], constants[2])) + computed_constants[14] = and_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[15] = and_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[16] = and_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[17] = and_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[18] = and_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[19] = and_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[20] = and_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[21] = and_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[22] = and_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[23] = and_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[24] = and_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[25] = and_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[26] = and_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[27] = constants[1]/and_func(constants[0], constants[2]) + computed_constants[28] = or_func(constants[1], constants[0]) + computed_constants[29] = or_func(constants[1], or_func(constants[0], constants[2])) + computed_constants[30] = or_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[31] = or_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[32] = or_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[33] = or_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[34] = or_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[35] = or_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[36] = or_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[37] = or_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[38] = or_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[39] = or_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[40] = or_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[41] = or_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[42] = or_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[43] = constants[1]/or_func(constants[0], constants[2]) + computed_constants[44] = xor_func(constants[1], constants[0]) + computed_constants[45] = xor_func(constants[1], xor_func(constants[0], constants[2])) + computed_constants[46] = xor_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[47] = xor_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[48] = xor_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[49] = xor_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[50] = xor_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[51] = xor_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[52] = xor_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[53] = xor_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[54] = xor_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[55] = xor_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[56] = xor_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[57] = xor_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[58] = xor_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[59] = constants[1]/xor_func(constants[0], constants[2]) + computed_constants[60] = not_func(constants[1]) + computed_constants[61] = constants[1]+constants[0]+constants[2] + computed_constants[62] = lt_func(constants[1], constants[0])+gt_func(constants[2], constants[3]) + computed_constants[63] = constants[1] + computed_constants[64] = constants[1]-constants[0] + computed_constants[65] = lt_func(constants[1], constants[0])-gt_func(constants[2], constants[3]) + computed_constants[66] = lt_func(constants[1], constants[0])-(constants[2]+constants[3]) + computed_constants[67] = lt_func(constants[1], constants[0])-constants[2] + computed_constants[68] = constants[1]-(-constants[0]) + computed_constants[69] = constants[1]-(-constants[0]*constants[2]) + computed_constants[70] = -constants[1] + computed_constants[71] = -lt_func(constants[1], constants[0]) + computed_constants[72] = constants[1]*constants[0] + computed_constants[73] = constants[1]*constants[0]*constants[2] + computed_constants[74] = lt_func(constants[1], constants[0])*gt_func(constants[2], constants[3]) + computed_constants[75] = (constants[1]+constants[0])*gt_func(constants[2], constants[3]) + computed_constants[76] = constants[1]*gt_func(constants[0], constants[2]) + computed_constants[77] = (constants[1]-constants[0])*gt_func(constants[2], constants[3]) + computed_constants[78] = -constants[1]*gt_func(constants[0], constants[2]) + computed_constants[79] = lt_func(constants[1], constants[0])*(constants[2]+constants[3]) + computed_constants[80] = lt_func(constants[1], constants[0])*constants[2] + computed_constants[81] = lt_func(constants[1], constants[0])*(constants[2]-constants[3]) + computed_constants[82] = lt_func(constants[1], constants[0])*-constants[2] + computed_constants[83] = constants[1]/constants[0] + computed_constants[84] = lt_func(constants[1], constants[0])/gt_func(constants[3], constants[2]) + computed_constants[85] = (constants[1]+constants[0])/gt_func(constants[3], constants[2]) + computed_constants[86] = constants[1]/gt_func(constants[2], constants[0]) + computed_constants[87] = (constants[1]-constants[0])/gt_func(constants[3], constants[2]) + computed_constants[88] = -constants[1]/gt_func(constants[2], constants[0]) + computed_constants[89] = lt_func(constants[1], constants[0])/(constants[2]+constants[3]) + computed_constants[90] = lt_func(constants[1], constants[0])/constants[2] + computed_constants[91] = lt_func(constants[1], constants[0])/(constants[2]-constants[3]) + computed_constants[92] = lt_func(constants[1], constants[0])/-constants[2] + computed_constants[93] = lt_func(constants[1], constants[0])/(constants[2]*constants[3]) + computed_constants[94] = lt_func(constants[1], constants[0])/(constants[2]/constants[3]) + computed_constants[95] = sqrt(constants[1]) + computed_constants[96] = pow(constants[1], 2.0) + computed_constants[97] = pow(constants[1], 3.0) + computed_constants[98] = pow(constants[1], constants[0]) + computed_constants[99] = pow(leq_func(constants[1], constants[0]), geq_func(constants[2], constants[3])) + computed_constants[100] = pow(constants[1]+constants[0], geq_func(constants[2], constants[3])) + computed_constants[101] = pow(constants[1], geq_func(constants[0], constants[2])) + computed_constants[102] = pow(constants[1]-constants[0], geq_func(constants[2], constants[3])) + computed_constants[103] = pow(-constants[1], geq_func(constants[0], constants[2])) + computed_constants[104] = pow(constants[1]*constants[0], geq_func(constants[2], constants[3])) + computed_constants[105] = pow(constants[1]/constants[0], geq_func(constants[2], constants[3])) + computed_constants[106] = pow(leq_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[107] = pow(leq_func(constants[1], constants[0]), constants[2]) + computed_constants[108] = pow(leq_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[109] = pow(leq_func(constants[1], constants[0]), -constants[2]) + computed_constants[110] = pow(leq_func(constants[1], constants[0]), constants[2]*constants[3]) + computed_constants[111] = pow(leq_func(constants[1], constants[0]), constants[2]/constants[3]) + computed_constants[112] = pow(leq_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[113] = pow(leq_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[114] = sqrt(constants[1]) + computed_constants[115] = sqrt(constants[1]) + computed_constants[116] = pow(constants[1], 1.0/3.0) + computed_constants[117] = pow(constants[1], 1.0/constants[0]) + computed_constants[118] = pow(lt_func(constants[1], constants[0]), 1.0/gt_func(constants[3], constants[2])) + computed_constants[119] = pow(constants[1]+constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[120] = pow(constants[1], 1.0/gt_func(constants[2], constants[0])) + computed_constants[121] = pow(constants[1]-constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[122] = pow(-constants[1], 1.0/gt_func(constants[2], constants[0])) + computed_constants[123] = pow(constants[1]*constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[124] = pow(constants[1]/constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[125] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]+constants[3])) + computed_constants[126] = pow(lt_func(constants[1], constants[0]), 1.0/constants[2]) + computed_constants[127] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]-constants[3])) + computed_constants[128] = pow(lt_func(constants[1], constants[0]), 1.0/-constants[2]) + computed_constants[129] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]*constants[3])) + computed_constants[130] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]/constants[3])) + computed_constants[131] = pow(lt_func(constants[1], constants[0]), 1.0/pow(constants[2], constants[3])) + computed_constants[132] = pow(lt_func(constants[1], constants[0]), 1.0/pow(constants[2], 1.0/constants[3])) + computed_constants[133] = fabs(constants[1]) + computed_constants[134] = exp(constants[1]) + computed_constants[135] = log(constants[1]) + computed_constants[136] = log10(constants[1]) + computed_constants[137] = log(constants[1])/log(2.0) + computed_constants[138] = log10(constants[1]) + computed_constants[139] = log(constants[1])/log(constants[0]) + computed_constants[140] = ceil(constants[1]) + computed_constants[141] = floor(constants[1]) + computed_constants[142] = min(constants[1], constants[0]) + computed_constants[143] = min(constants[1], min(constants[0], constants[2])) + computed_constants[144] = max(constants[1], constants[0]) + computed_constants[145] = max(constants[1], max(constants[0], constants[2])) + computed_constants[146] = fmod(constants[1], constants[0]) + computed_constants[147] = sin(constants[1]) + computed_constants[148] = cos(constants[1]) + computed_constants[149] = tan(constants[1]) + computed_constants[150] = sec(constants[1]) + computed_constants[151] = csc(constants[1]) + computed_constants[152] = cot(constants[1]) + computed_constants[153] = sinh(constants[1]) + computed_constants[154] = cosh(constants[1]) + computed_constants[155] = tanh(constants[1]) + computed_constants[156] = sech(constants[1]) + computed_constants[157] = csch(constants[1]) + computed_constants[158] = coth(constants[1]) + computed_constants[159] = asin(constants[1]) + computed_constants[160] = acos(constants[1]) + computed_constants[161] = atan(constants[1]) + computed_constants[162] = asec(constants[1]) + computed_constants[163] = acsc(constants[1]) + computed_constants[164] = acot(constants[1]) + computed_constants[165] = asinh(constants[1]) + computed_constants[166] = acosh(constants[1]) + computed_constants[167] = atanh(constants[1]/2.0) + computed_constants[168] = asech(constants[1]) + computed_constants[169] = acsch(constants[1]) + computed_constants[170] = acoth(2.0*constants[1]) + computed_constants[171] = constants[1] if gt_func(constants[1], constants[0]) else nan + computed_constants[172] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] + computed_constants[173] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan + computed_constants[174] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] + computed_constants[175] = 123.0+(constants[1] if gt_func(constants[1], constants[0]) else nan) + computed_constants[180] = constants[1] + computed_constants[187] = and_func(constants[1], constants[0])+(constants[0] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) + computed_constants[188] = and_func(constants[1], constants[0])-((constants[0] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[0] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) + computed_constants[189] = and_func(constants[1], constants[0])*(constants[0] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[0] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) + computed_constants[190] = and_func(constants[1], constants[0])/((constants[0] if gt_func(constants[2], constants[3]) else nan)/(constants[4]/(constants[0] if gt_func(constants[2], constants[3]) else nan))) + computed_constants[191] = and_func(or_func(constants[1], constants[0]), and_func(xor_func(constants[1], constants[0]), and_func(constants[0] if gt_func(constants[2], constants[3]) else nan, and_func(and_func(and_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[1], constants[0])), or_func(constants[1], constants[0]))))) + computed_constants[192] = or_func(and_func(constants[1], constants[0]), or_func(xor_func(constants[1], constants[0]), or_func(constants[0] if gt_func(constants[2], constants[3]) else nan, or_func(or_func(or_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[1], constants[0])), and_func(constants[1], constants[0]))))) + computed_constants[193] = xor_func(and_func(constants[1], constants[0]), xor_func(or_func(constants[1], constants[0]), xor_func(constants[0] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), or_func(constants[1], constants[0])), and_func(constants[1], constants[0]))))) + computed_constants[194] = pow(and_func(constants[1], constants[0]), pow(constants[0] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), and_func(constants[1], constants[0])))) + computed_constants[195] = pow(pow(pow(and_func(constants[1], constants[0]), 1.0/pow(constants[0] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[0] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[1], constants[0])) + computed_constants[196] = -and_func(constants[1], constants[0])-(constants[0] if gt_func(constants[2], constants[3]) else nan) + computed_constants[197] = computed_constants[199]+computed_constants[198] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + rates[0] = 1.0 + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) diff --git a/tests/resources/coverage/generator/model.modified.profile_macos.c b/tests/resources/coverage/generator/model.modified.profile_macos.c new file mode 100644 index 0000000000..65676690f7 --- /dev/null +++ b/tests/resources/coverage/generator/model.modified.profile_macos.c @@ -0,0 +1,657 @@ +/* The content of this file was generated using a modified C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0.post0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 1; +const size_t CONSTANT_COUNT = 7; +const size_t COMPUTED_CONSTANT_COUNT = 200; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"t", "second", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"n", "dimensionless", "my_component"}, + {"m", "dimensionless", "my_component"}, + {"o", "dimensionless", "my_component"}, + {"p", "dimensionless", "my_component"}, + {"q", "dimensionless", "my_component"}, + {"r", "dimensionless", "my_component"}, + {"s", "dimensionless", "my_component"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"eqnEq", "dimensionless", "my_component"}, + {"eqnEqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnNeq", "dimensionless", "my_component"}, + {"eqnNeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnLt", "dimensionless", "my_component"}, + {"eqnLtCoverageParentheses", "dimensionless", "my_component"}, + {"eqnLeq", "dimensionless", "my_component"}, + {"eqnLeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnGt", "dimensionless", "my_component"}, + {"eqnGtCoverageParentheses", "dimensionless", "my_component"}, + {"eqnGeq", "dimensionless", "my_component"}, + {"eqnGeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnAnd", "dimensionless", "my_component"}, + {"eqnAndMultiple", "dimensionless", "my_component"}, + {"eqnAndParentheses", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnAndCoverageParentheses", "dimensionless", "my_component"}, + {"eqnOr", "dimensionless", "my_component"}, + {"eqnOrMultiple", "dimensionless", "my_component"}, + {"eqnOrParentheses", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnOrCoverageParentheses", "dimensionless", "my_component"}, + {"eqnXor", "dimensionless", "my_component"}, + {"eqnXorMultiple", "dimensionless", "my_component"}, + {"eqnXorParentheses", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnXorCoverageParentheses", "dimensionless", "my_component"}, + {"eqnNot", "dimensionless", "my_component"}, + {"eqnPlusMultiple", "dimensionless", "my_component"}, + {"eqnPlusParentheses", "dimensionless", "my_component"}, + {"eqnPlusUnary", "dimensionless", "my_component"}, + {"eqnMinus", "dimensionless", "my_component"}, + {"eqnMinusParentheses", "dimensionless", "my_component"}, + {"eqnMinusParenthesesPlusWith", "dimensionless", "my_component"}, + {"eqnMinusParenthesesPlusWithout", "dimensionless", "my_component"}, + {"eqnMinusParenthesesDirectUnaryMinus", "dimensionless", "my_component"}, + {"eqnMinusParenthesesIndirectUnaryMinus", "dimensionless", "my_component"}, + {"eqnMinusUnary", "dimensionless", "my_component"}, + {"eqnMinusUnaryParentheses", "dimensionless", "my_component"}, + {"eqnTimes", "dimensionless", "my_component"}, + {"eqnTimesMultiple", "dimensionless", "my_component"}, + {"eqnTimesParentheses", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnDivide", "dimensionless", "my_component"}, + {"eqnDivideParentheses", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnPowerSqrt", "dimensionless", "my_component"}, + {"eqnPowerSqr", "dimensionless", "my_component"}, + {"eqnPowerCube", "dimensionless", "my_component"}, + {"eqnPowerCi", "dimensionless", "my_component"}, + {"eqnPowerParentheses", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftTimes", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftDivide", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnRootSqrt", "dimensionless", "my_component"}, + {"eqnRootSqrtOther", "dimensionless", "my_component"}, + {"eqnRootCube", "dimensionless", "my_component"}, + {"eqnRootCi", "dimensionless", "my_component"}, + {"eqnRootParentheses", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftTimes", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftDivide", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnAbs", "dimensionless", "my_component"}, + {"eqnExp", "dimensionless", "my_component"}, + {"eqnLn", "dimensionless", "my_component"}, + {"eqnLog", "dimensionless", "my_component"}, + {"eqnLog2", "dimensionless", "my_component"}, + {"eqnLog10", "dimensionless", "my_component"}, + {"eqnLogCi", "dimensionless", "my_component"}, + {"eqnCeiling", "dimensionless", "my_component"}, + {"eqnFloor", "dimensionless", "my_component"}, + {"eqnMin", "dimensionless", "my_component"}, + {"eqnMinMultiple", "dimensionless", "my_component"}, + {"eqnMax", "dimensionless", "my_component"}, + {"eqnMaxMultiple", "dimensionless", "my_component"}, + {"eqnRem", "dimensionless", "my_component"}, + {"eqnSin", "dimensionless", "my_component"}, + {"eqnCos", "dimensionless", "my_component"}, + {"eqnTan", "dimensionless", "my_component"}, + {"eqnSec", "dimensionless", "my_component"}, + {"eqnCsc", "dimensionless", "my_component"}, + {"eqnCot", "dimensionless", "my_component"}, + {"eqnSinh", "dimensionless", "my_component"}, + {"eqnCosh", "dimensionless", "my_component"}, + {"eqnTanh", "dimensionless", "my_component"}, + {"eqnSech", "dimensionless", "my_component"}, + {"eqnCsch", "dimensionless", "my_component"}, + {"eqnCoth", "dimensionless", "my_component"}, + {"eqnArcsin", "dimensionless", "my_component"}, + {"eqnArccos", "dimensionless", "my_component"}, + {"eqnArctan", "dimensionless", "my_component"}, + {"eqnArcsec", "dimensionless", "my_component"}, + {"eqnArccsc", "dimensionless", "my_component"}, + {"eqnArccot", "dimensionless", "my_component"}, + {"eqnArcsinh", "dimensionless", "my_component"}, + {"eqnArccosh", "dimensionless", "my_component"}, + {"eqnArctanh", "dimensionless", "my_component"}, + {"eqnArcsech", "dimensionless", "my_component"}, + {"eqnArccsch", "dimensionless", "my_component"}, + {"eqnArccoth", "dimensionless", "my_component"}, + {"eqnPiecewisePiece", "dimensionless", "my_component"}, + {"eqnPiecewisePieceOtherwise", "dimensionless", "my_component"}, + {"eqnPiecewisePiecePiecePiece", "dimensionless", "my_component"}, + {"eqnPiecewisePiecePiecePieceOtherwise", "dimensionless", "my_component"}, + {"eqnWithPiecewise", "dimensionless", "my_component"}, + {"eqnCnInteger", "dimensionless", "my_component"}, + {"eqnCnDouble", "dimensionless", "my_component"}, + {"eqnCnIntegerWithExponent", "dimensionless", "my_component"}, + {"eqnCnDoubleWithExponent", "dimensionless", "my_component"}, + {"eqnCi", "dimensionless", "my_component"}, + {"eqnTrue", "dimensionless", "my_component"}, + {"eqnFalse", "dimensionless", "my_component"}, + {"eqnExponentiale", "dimensionless", "my_component"}, + {"eqnPi", "dimensionless", "my_component"}, + {"eqnInfinity", "dimensionless", "my_component"}, + {"eqnNotanumber", "dimensionless", "my_component"}, + {"eqnCoverageForPlusOperator", "dimensionless", "my_component"}, + {"eqnCoverageForMinusOperator", "dimensionless", "my_component"}, + {"eqnCoverageForTimesOperator", "dimensionless", "my_component"}, + {"eqnCoverageForDivideOperator", "dimensionless", "my_component"}, + {"eqnCoverageForAndOperator", "dimensionless", "my_component"}, + {"eqnCoverageForOrOperator", "dimensionless", "my_component"}, + {"eqnCoverageForXorOperator", "dimensionless", "my_component"}, + {"eqnCoverageForPowerOperator", "dimensionless", "my_component"}, + {"eqnCoverageForRootOperator", "dimensionless", "my_component"}, + {"eqnCoverageForMinusUnary", "dimensionless", "my_component"}, + {"eqnComputedConstant3", "dimensionless", "my_component"}, + {"eqnComputedConstant2", "dimensionless", "my_component"}, + {"eqnComputedConstant1", "dimensionless", "my_component"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"eqnNlaVariable2", "dimensionless", "my_component"}, + {"eqnNlaVariable1", "dimensionless", "my_component"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"eqnPlus", "dimensionless", "my_component"} +}; + +double xor(double x, double y) +{ + return (x != 0.0) ^ (y != 0.0); +} + +double min(double x, double y) +{ + return (x < y)?x:y; +} + +double max(double x, double y) +{ + return (x > y)?x:y; +} + +double sec(double x) +{ + return 1.0/cos(x); +} + +double csc(double x) +{ + return 1.0/sin(x); +} + +double cot(double x) +{ + return 1.0/tan(x); +} + +double sech(double x) +{ + return 1.0/cosh(x); +} + +double csch(double x) +{ + return 1.0/sinh(x); +} + +double coth(double x) +{ + return 1.0/tanh(x); +} + +double asec(double x) +{ + return acos(1.0/x); +} + +double acsc(double x) +{ + return asin(1.0/x); +} + +double acot(double x) +{ + return atan(1.0/x); +} + +double asech(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX-1.0)); +} + +double acsch(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX+1.0)); +} + +double acoth(double x) +{ + double oneOverX = 1.0/x; + + return 0.5*log((1.0+oneOverX)/(1.0-oneOverX)); +} + +double * createStatesVector() +{ + 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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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; + double *externalVariables; +} 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; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; + + f[0] = sin(algebraicVariables[1])+sin(algebraicVariables[0])+states[0]+computedConstants[197]+constants[1]-1.0; + f[1] = -computedConstants[197]-sin(algebraicVariables[0])-computedConstants[198]-computedConstants[199]+sin(algebraicVariables[1])-0.5; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; + double u[2]; + + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; + + nlaSolve(objectiveFunction0, u, 2, &rfi); + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + constants[0] = 1.23; + constants[1] = 123.0; + constants[2] = 1.0e1; + constants[3] = 1.23e1; + constants[4] = 1.0E1; + constants[5] = 1.23E1; + constants[6] = 7.0; + computedConstants[176] = 123.0; + computedConstants[177] = 123.456789; + computedConstants[178] = 123.0e99; + computedConstants[179] = 123.456789e99; + computedConstants[181] = 1.0; + computedConstants[182] = 0.0; + computedConstants[183] = 2.71828182845905; + computedConstants[184] = 3.14159265358979; + computedConstants[185] = INFINITY; + computedConstants[186] = NAN; + computedConstants[199] = 1.0; + computedConstants[198] = 3.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[1] == constants[0]; + computedConstants[1] = constants[1]/(constants[0] == constants[0]); + computedConstants[2] = constants[1] != constants[0]; + computedConstants[3] = constants[1]/(constants[0] != constants[2]); + computedConstants[4] = constants[1] < constants[0]; + computedConstants[5] = constants[1]/(constants[0] < constants[2]); + computedConstants[6] = constants[1] <= constants[0]; + computedConstants[7] = constants[1]/(constants[0] <= constants[2]); + computedConstants[8] = constants[1] > constants[0]; + computedConstants[9] = constants[1]/(constants[0] > constants[2]); + computedConstants[10] = constants[1] >= constants[0]; + computedConstants[11] = constants[1]/(constants[0] >= constants[2]); + computedConstants[12] = constants[1] && constants[0]; + computedConstants[13] = constants[1] && constants[0] && constants[2]; + computedConstants[14] = (constants[1] < constants[0]) && (constants[2] > constants[3]); + computedConstants[15] = (constants[1]+constants[0]) && (constants[2] > constants[3]); + computedConstants[16] = constants[1] && (constants[0] > constants[2]); + computedConstants[17] = (constants[1]-constants[0]) && (constants[2] > constants[3]); + computedConstants[18] = -constants[1] && (constants[0] > constants[2]); + computedConstants[19] = pow(constants[1], constants[0]) && (constants[2] > constants[3]); + computedConstants[20] = pow(constants[1], 1.0/constants[0]) && (constants[2] > constants[3]); + computedConstants[21] = (constants[1] < constants[0]) && (constants[2]+constants[3]); + computedConstants[22] = (constants[1] < constants[0]) && constants[2]; + computedConstants[23] = (constants[1] < constants[0]) && (constants[2]-constants[3]); + computedConstants[24] = (constants[1] < constants[0]) && -constants[2]; + computedConstants[25] = (constants[1] < constants[0]) && pow(constants[2], constants[3]); + computedConstants[26] = (constants[1] < constants[0]) && pow(constants[2], 1.0/constants[3]); + computedConstants[27] = constants[1]/(constants[0] && constants[2]); + computedConstants[28] = constants[1] || constants[0]; + computedConstants[29] = constants[1] || constants[0] || constants[2]; + computedConstants[30] = (constants[1] < constants[0]) || (constants[2] > constants[3]); + computedConstants[31] = (constants[1]+constants[0]) || (constants[2] > constants[3]); + computedConstants[32] = constants[1] || (constants[0] > constants[2]); + computedConstants[33] = (constants[1]-constants[0]) || (constants[2] > constants[3]); + computedConstants[34] = -constants[1] || (constants[0] > constants[2]); + computedConstants[35] = pow(constants[1], constants[0]) || (constants[2] > constants[3]); + computedConstants[36] = pow(constants[1], 1.0/constants[0]) || (constants[2] > constants[3]); + computedConstants[37] = (constants[1] < constants[0]) || (constants[2]+constants[3]); + computedConstants[38] = (constants[1] < constants[0]) || constants[2]; + computedConstants[39] = (constants[1] < constants[0]) || (constants[2]-constants[3]); + computedConstants[40] = (constants[1] < constants[0]) || -constants[2]; + computedConstants[41] = (constants[1] < constants[0]) || pow(constants[2], constants[3]); + computedConstants[42] = (constants[1] < constants[0]) || pow(constants[2], 1.0/constants[3]); + computedConstants[43] = constants[1]/(constants[0] || constants[2]); + computedConstants[44] = xor(constants[1], constants[0]); + computedConstants[45] = xor(constants[1], xor(constants[0], constants[2])); + computedConstants[46] = xor(constants[1] < constants[0], constants[2] > constants[3]); + computedConstants[47] = xor(constants[1]+constants[0], constants[2] > constants[3]); + computedConstants[48] = xor(constants[1], constants[0] > constants[2]); + computedConstants[49] = xor(constants[1]-constants[0], constants[2] > constants[3]); + computedConstants[50] = xor(-constants[1], constants[0] > constants[2]); + computedConstants[51] = xor(pow(constants[1], constants[0]), constants[2] > constants[3]); + computedConstants[52] = xor(pow(constants[1], 1.0/constants[0]), constants[2] > constants[3]); + computedConstants[53] = xor(constants[1] < constants[0], constants[2]+constants[3]); + computedConstants[54] = xor(constants[1] < constants[0], constants[2]); + computedConstants[55] = xor(constants[1] < constants[0], constants[2]-constants[3]); + computedConstants[56] = xor(constants[1] < constants[0], -constants[2]); + computedConstants[57] = xor(constants[1] < constants[0], pow(constants[2], constants[3])); + computedConstants[58] = xor(constants[1] < constants[0], pow(constants[2], 1.0/constants[3])); + computedConstants[59] = constants[1]/xor(constants[0], constants[2]); + computedConstants[60] = !constants[1]; + computedConstants[61] = constants[1]+constants[0]+constants[2]; + computedConstants[62] = (constants[1] < constants[0])+(constants[2] > constants[3]); + computedConstants[63] = constants[1]; + computedConstants[64] = constants[1]-constants[0]; + computedConstants[65] = (constants[1] < constants[0])-(constants[2] > constants[3]); + computedConstants[66] = (constants[1] < constants[0])-(constants[2]+constants[3]); + computedConstants[67] = (constants[1] < constants[0])-constants[2]; + computedConstants[68] = constants[1]-(-constants[0]); + computedConstants[69] = constants[1]-(-constants[0]*constants[2]); + computedConstants[70] = -constants[1]; + computedConstants[71] = -(constants[1] < constants[0]); + computedConstants[72] = constants[1]*constants[0]; + computedConstants[73] = constants[1]*constants[0]*constants[2]; + computedConstants[74] = (constants[1] < constants[0])*(constants[2] > constants[3]); + computedConstants[75] = (constants[1]+constants[0])*(constants[2] > constants[3]); + computedConstants[76] = constants[1]*(constants[0] > constants[2]); + computedConstants[77] = (constants[1]-constants[0])*(constants[2] > constants[3]); + computedConstants[78] = -constants[1]*(constants[0] > constants[2]); + computedConstants[79] = (constants[1] < constants[0])*(constants[2]+constants[3]); + computedConstants[80] = (constants[1] < constants[0])*constants[2]; + computedConstants[81] = (constants[1] < constants[0])*(constants[2]-constants[3]); + computedConstants[82] = (constants[1] < constants[0])*-constants[2]; + computedConstants[83] = constants[1]/constants[0]; + computedConstants[84] = (constants[1] < constants[0])/(constants[3] > constants[2]); + computedConstants[85] = (constants[1]+constants[0])/(constants[3] > constants[2]); + computedConstants[86] = constants[1]/(constants[2] > constants[0]); + computedConstants[87] = (constants[1]-constants[0])/(constants[3] > constants[2]); + computedConstants[88] = -constants[1]/(constants[2] > constants[0]); + computedConstants[89] = (constants[1] < constants[0])/(constants[2]+constants[3]); + computedConstants[90] = (constants[1] < constants[0])/constants[2]; + computedConstants[91] = (constants[1] < constants[0])/(constants[2]-constants[3]); + computedConstants[92] = (constants[1] < constants[0])/-constants[2]; + computedConstants[93] = (constants[1] < constants[0])/(constants[2]*constants[3]); + computedConstants[94] = (constants[1] < constants[0])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[1]); + computedConstants[96] = pow(constants[1], 2.0); + computedConstants[97] = pow(constants[1], 3.0); + computedConstants[98] = pow(constants[1], constants[0]); + computedConstants[99] = pow(constants[1] <= constants[0], constants[2] >= constants[3]); + computedConstants[100] = pow(constants[1]+constants[0], constants[2] >= constants[3]); + computedConstants[101] = pow(constants[1], constants[0] >= constants[2]); + computedConstants[102] = pow(constants[1]-constants[0], constants[2] >= constants[3]); + computedConstants[103] = pow(-constants[1], constants[0] >= constants[2]); + computedConstants[104] = pow(constants[1]*constants[0], constants[2] >= constants[3]); + computedConstants[105] = pow(constants[1]/constants[0], constants[2] >= constants[3]); + computedConstants[106] = pow(constants[1] <= constants[0], constants[2]+constants[3]); + computedConstants[107] = pow(constants[1] <= constants[0], constants[2]); + computedConstants[108] = pow(constants[1] <= constants[0], constants[2]-constants[3]); + computedConstants[109] = pow(constants[1] <= constants[0], -constants[2]); + computedConstants[110] = pow(constants[1] <= constants[0], constants[2]*constants[3]); + computedConstants[111] = pow(constants[1] <= constants[0], constants[2]/constants[3]); + computedConstants[112] = pow(constants[1] <= constants[0], pow(constants[2], constants[3])); + computedConstants[113] = pow(constants[1] <= constants[0], pow(constants[2], 1.0/constants[3])); + computedConstants[114] = sqrt(constants[1]); + computedConstants[115] = sqrt(constants[1]); + computedConstants[116] = pow(constants[1], 1.0/3.0); + computedConstants[117] = pow(constants[1], 1.0/constants[0]); + computedConstants[118] = pow(constants[1] < constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[119] = pow(constants[1]+constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[120] = pow(constants[1], 1.0/(constants[2] > constants[0])); + computedConstants[121] = pow(constants[1]-constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[122] = pow(-constants[1], 1.0/(constants[2] > constants[0])); + computedConstants[123] = pow(constants[1]*constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[124] = pow(constants[1]/constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[125] = pow(constants[1] < constants[0], 1.0/(constants[2]+constants[3])); + computedConstants[126] = pow(constants[1] < constants[0], 1.0/constants[2]); + computedConstants[127] = pow(constants[1] < constants[0], 1.0/(constants[2]-constants[3])); + computedConstants[128] = pow(constants[1] < constants[0], 1.0/-constants[2]); + computedConstants[129] = pow(constants[1] < constants[0], 1.0/(constants[2]*constants[3])); + computedConstants[130] = pow(constants[1] < constants[0], 1.0/(constants[2]/constants[3])); + computedConstants[131] = pow(constants[1] < constants[0], 1.0/pow(constants[2], constants[3])); + computedConstants[132] = pow(constants[1] < constants[0], 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[133] = fabs(constants[1]); + computedConstants[134] = exp(constants[1]); + computedConstants[135] = log(constants[1]); + computedConstants[136] = log10(constants[1]); + computedConstants[137] = log(constants[1])/log(2.0); + computedConstants[138] = log10(constants[1]); + computedConstants[139] = log(constants[1])/log(constants[0]); + computedConstants[140] = ceil(constants[1]); + computedConstants[141] = floor(constants[1]); + computedConstants[142] = min(constants[1], constants[0]); + computedConstants[143] = min(constants[1], min(constants[0], constants[2])); + computedConstants[144] = max(constants[1], constants[0]); + computedConstants[145] = max(constants[1], max(constants[0], constants[2])); + computedConstants[146] = fmod(constants[1], constants[0]); + computedConstants[147] = sin(constants[1]); + computedConstants[148] = cos(constants[1]); + computedConstants[149] = tan(constants[1]); + computedConstants[150] = sec(constants[1]); + computedConstants[151] = csc(constants[1]); + computedConstants[152] = cot(constants[1]); + computedConstants[153] = sinh(constants[1]); + computedConstants[154] = cosh(constants[1]); + computedConstants[155] = tanh(constants[1]); + computedConstants[156] = sech(constants[1]); + computedConstants[157] = csch(constants[1]); + computedConstants[158] = coth(constants[1]); + computedConstants[159] = asin(constants[1]); + computedConstants[160] = acos(constants[1]); + computedConstants[161] = atan(constants[1]); + computedConstants[162] = asec(constants[1]); + computedConstants[163] = acsc(constants[1]); + computedConstants[164] = acot(constants[1]); + computedConstants[165] = asinh(constants[1]); + computedConstants[166] = acosh(constants[1]); + computedConstants[167] = atanh(constants[1]/2.0); + computedConstants[168] = asech(constants[1]); + computedConstants[169] = acsch(constants[1]); + computedConstants[170] = acoth(2.0*constants[1]); + computedConstants[171] = (constants[1] > constants[0])?constants[1]:NAN; + computedConstants[172] = (constants[1] > constants[0])?constants[1]:constants[2]; + computedConstants[173] = (constants[1] > constants[0])?constants[1]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; + computedConstants[174] = (constants[1] > constants[0])?constants[1]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; + computedConstants[175] = 123.0+((constants[1] > constants[0])?constants[1]:NAN); + computedConstants[180] = constants[1]; + computedConstants[187] = (constants[1] && constants[0])+((constants[2] > constants[3])?constants[0]:NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[188] = (constants[1] && constants[0])-(((constants[2] > constants[3])?constants[0]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[0]:NAN)))-(constants[5] && constants[6]); + computedConstants[189] = (constants[1] && constants[0])*((constants[2] > constants[3])?constants[0]:NAN)*constants[4]*((constants[2] > constants[3])?constants[0]:NAN)*(constants[5] && constants[6]); + computedConstants[190] = (constants[1] && constants[0])/(((constants[2] > constants[3])?constants[0]:NAN)/(constants[4]/((constants[2] > constants[3])?constants[0]:NAN))); + computedConstants[191] = (constants[1] || constants[0]) && xor(constants[1], constants[0]) && ((constants[2] > constants[3])?constants[0]:NAN) && constants[4] && ((constants[2] > constants[3])?constants[0]:NAN) && xor(constants[1], constants[0]) && (constants[1] || constants[0]); + computedConstants[192] = (constants[1] && constants[0]) || xor(constants[1], constants[0]) || ((constants[2] > constants[3])?constants[0]:NAN) || constants[4] || ((constants[2] > constants[3])?constants[0]:NAN) || xor(constants[1], constants[0]) || (constants[1] && constants[0]); + computedConstants[193] = xor(constants[1] && constants[0], xor(constants[1] || constants[0], xor((constants[2] > constants[3])?constants[0]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] || constants[0]), constants[1] && constants[0])))); + computedConstants[194] = pow(constants[1] && constants[0], pow((constants[2] > constants[3])?constants[0]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] && constants[0]))); + computedConstants[195] = pow(pow(pow(constants[1] && constants[0], 1.0/pow((constants[2] > constants[3])?constants[0]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[0]:NAN)), 1.0/(constants[1] && constants[0])); + computedConstants[196] = -(constants[1] && constants[0])-((constants[2] > constants[3])?constants[0]:NAN); + computedConstants[197] = computedConstants[199]+computedConstants[198]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + rates[0] = 1.0; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); +} diff --git a/tests/resources/coverage/generator/model.modified.profile_macos.py b/tests/resources/coverage/generator/model.modified.profile_macos.py new file mode 100644 index 0000000000..a24540f8d4 --- /dev/null +++ b/tests/resources/coverage/generator/model.modified.profile_macos.py @@ -0,0 +1,620 @@ +# The content of this file was generated using a modified Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0.post0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 1 +CONSTANT_COUNT = 7 +COMPUTED_CONSTANT_COUNT = 200 +ALGEBRAIC_VARIABLE_COUNT = 2 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} + +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ + {"name": "n", "units": "dimensionless", "component": "my_component"}, + {"name": "m", "units": "dimensionless", "component": "my_component"}, + {"name": "o", "units": "dimensionless", "component": "my_component"}, + {"name": "p", "units": "dimensionless", "component": "my_component"}, + {"name": "q", "units": "dimensionless", "component": "my_component"}, + {"name": "r", "units": "dimensionless", "component": "my_component"}, + {"name": "s", "units": "dimensionless", "component": "my_component"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "eqnEq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnEqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLtCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGtCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAnd", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOr", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXor", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesDirectUnaryMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesIndirectUnaryMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusUnaryParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerSqrt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerSqr", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerCube", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootSqrt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootSqrtOther", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootCube", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAbs", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnExp", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLn", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog10", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLogCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCeiling", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnFloor", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMax", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMaxMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRem", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCos", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTan", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSec", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCsc", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSinh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCosh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTanh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSech", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCsch", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoth", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccos", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArctan", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsec", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccsc", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsinh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccosh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArctanh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsech", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccsch", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccoth", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiece", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePieceOtherwise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiecePiecePiece", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiecePiecePieceOtherwise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnWithPiecewise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnInteger", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnDouble", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnIntegerWithExponent", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnDoubleWithExponent", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTrue", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnFalse", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnExponentiale", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnInfinity", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNotanumber", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForPlusOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForMinusOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForTimesOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForDivideOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForAndOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForOrOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForXorOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForPowerOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant3", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "eqnPlus", "units": "dimensionless", "component": "my_component"} +] + + +def eq_func(x, y): + return 1.0 if x == y else 0.0 + + +def neq_func(x, y): + return 1.0 if x != y else 0.0 + + +def lt_func(x, y): + return 1.0 if x < y else 0.0 + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def gt_func(x, y): + return 1.0 if x > y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def or_func(x, y): + return 1.0 if bool(x) | bool(y) else 0.0 + + +def xor_func(x, y): + return 1.0 if bool(x) ^ bool(y) else 0.0 + + +def not_func(x): + return 1.0 if not bool(x) else 0.0 + + +def min(x, y): + return x if x < y else y + + +def max(x, y): + return x if x > y else y + + +def sec(x): + return 1.0/cos(x) + + +def csc(x): + return 1.0/sin(x) + + +def cot(x): + return 1.0/tan(x) + + +def sech(x): + return 1.0/cosh(x) + + +def csch(x): + return 1.0/sinh(x) + + +def coth(x): + return 1.0/tanh(x) + + +def asec(x): + return acos(1.0/x) + + +def acsc(x): + return asin(1.0/x) + + +def acot(x): + return atan(1.0/x) + + +def asech(x): + one_over_x = 1.0/x + + return log(one_over_x+sqrt(one_over_x*one_over_x-1.0)) + + +def acsch(x): + one_over_x = 1.0/x + + return log(one_over_x+sqrt(one_over_x*one_over_x+1.0)) + + +def acoth(x): + one_over_x = 1.0/x + + return 0.5*log((1.0+one_over_x)/(1.0-one_over_x)) + + +def create_states_vector(): + 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 create_external_variables_array(): + return [nan]*EXTERNAL_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] + external_variables = data[6] + + algebraic_variables[0] = u[0] + algebraic_variables[1] = u[1] + + f[0] = sin(algebraic_variables[1])+sin(algebraic_variables[0])+states[0]+computed_constants[197]+constants[1]-1.0 + f[1] = -computed_constants[197]-sin(algebraic_variables[0])-computed_constants[198]-computed_constants[199]+sin(algebraic_variables[1])-0.5 + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): + u = [nan]*2 + + u[0] = algebraic_variables[0] + u[1] = algebraic_variables[1] + + u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) + + algebraic_variables[0] = u[0] + algebraic_variables[1] = u[1] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + constants[0] = 1.23 + constants[1] = 123.0 + constants[2] = 1.0e1 + constants[3] = 1.23e1 + constants[4] = 1.0E1 + constants[5] = 1.23E1 + constants[6] = 7.0 + computed_constants[176] = 123.0 + computed_constants[177] = 123.456789 + computed_constants[178] = 123.0e99 + computed_constants[179] = 123.456789e99 + computed_constants[181] = 1.0 + computed_constants[182] = 0.0 + computed_constants[183] = 2.71828182845905 + computed_constants[184] = 3.14159265358979 + computed_constants[185] = inf + computed_constants[186] = nan + computed_constants[199] = 1.0 + computed_constants[198] = 3.0 + algebraic_variables[0] = 0.0 + algebraic_variables[1] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = eq_func(constants[1], constants[0]) + computed_constants[1] = constants[1]/eq_func(constants[0], constants[0]) + computed_constants[2] = neq_func(constants[1], constants[0]) + computed_constants[3] = constants[1]/neq_func(constants[0], constants[2]) + computed_constants[4] = lt_func(constants[1], constants[0]) + computed_constants[5] = constants[1]/lt_func(constants[0], constants[2]) + computed_constants[6] = leq_func(constants[1], constants[0]) + computed_constants[7] = constants[1]/leq_func(constants[0], constants[2]) + computed_constants[8] = gt_func(constants[1], constants[0]) + computed_constants[9] = constants[1]/gt_func(constants[0], constants[2]) + computed_constants[10] = geq_func(constants[1], constants[0]) + computed_constants[11] = constants[1]/geq_func(constants[0], constants[2]) + computed_constants[12] = and_func(constants[1], constants[0]) + computed_constants[13] = and_func(constants[1], and_func(constants[0], constants[2])) + computed_constants[14] = and_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[15] = and_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[16] = and_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[17] = and_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[18] = and_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[19] = and_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[20] = and_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[21] = and_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[22] = and_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[23] = and_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[24] = and_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[25] = and_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[26] = and_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[27] = constants[1]/and_func(constants[0], constants[2]) + computed_constants[28] = or_func(constants[1], constants[0]) + computed_constants[29] = or_func(constants[1], or_func(constants[0], constants[2])) + computed_constants[30] = or_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[31] = or_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[32] = or_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[33] = or_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[34] = or_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[35] = or_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[36] = or_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[37] = or_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[38] = or_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[39] = or_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[40] = or_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[41] = or_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[42] = or_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[43] = constants[1]/or_func(constants[0], constants[2]) + computed_constants[44] = xor_func(constants[1], constants[0]) + computed_constants[45] = xor_func(constants[1], xor_func(constants[0], constants[2])) + computed_constants[46] = xor_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[47] = xor_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[48] = xor_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[49] = xor_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[50] = xor_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[51] = xor_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[52] = xor_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[53] = xor_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[54] = xor_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[55] = xor_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[56] = xor_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[57] = xor_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[58] = xor_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[59] = constants[1]/xor_func(constants[0], constants[2]) + computed_constants[60] = not_func(constants[1]) + computed_constants[61] = constants[1]+constants[0]+constants[2] + computed_constants[62] = lt_func(constants[1], constants[0])+gt_func(constants[2], constants[3]) + computed_constants[63] = constants[1] + computed_constants[64] = constants[1]-constants[0] + computed_constants[65] = lt_func(constants[1], constants[0])-gt_func(constants[2], constants[3]) + computed_constants[66] = lt_func(constants[1], constants[0])-(constants[2]+constants[3]) + computed_constants[67] = lt_func(constants[1], constants[0])-constants[2] + computed_constants[68] = constants[1]-(-constants[0]) + computed_constants[69] = constants[1]-(-constants[0]*constants[2]) + computed_constants[70] = -constants[1] + computed_constants[71] = -lt_func(constants[1], constants[0]) + computed_constants[72] = constants[1]*constants[0] + computed_constants[73] = constants[1]*constants[0]*constants[2] + computed_constants[74] = lt_func(constants[1], constants[0])*gt_func(constants[2], constants[3]) + computed_constants[75] = (constants[1]+constants[0])*gt_func(constants[2], constants[3]) + computed_constants[76] = constants[1]*gt_func(constants[0], constants[2]) + computed_constants[77] = (constants[1]-constants[0])*gt_func(constants[2], constants[3]) + computed_constants[78] = -constants[1]*gt_func(constants[0], constants[2]) + computed_constants[79] = lt_func(constants[1], constants[0])*(constants[2]+constants[3]) + computed_constants[80] = lt_func(constants[1], constants[0])*constants[2] + computed_constants[81] = lt_func(constants[1], constants[0])*(constants[2]-constants[3]) + computed_constants[82] = lt_func(constants[1], constants[0])*-constants[2] + computed_constants[83] = constants[1]/constants[0] + computed_constants[84] = lt_func(constants[1], constants[0])/gt_func(constants[3], constants[2]) + computed_constants[85] = (constants[1]+constants[0])/gt_func(constants[3], constants[2]) + computed_constants[86] = constants[1]/gt_func(constants[2], constants[0]) + computed_constants[87] = (constants[1]-constants[0])/gt_func(constants[3], constants[2]) + computed_constants[88] = -constants[1]/gt_func(constants[2], constants[0]) + computed_constants[89] = lt_func(constants[1], constants[0])/(constants[2]+constants[3]) + computed_constants[90] = lt_func(constants[1], constants[0])/constants[2] + computed_constants[91] = lt_func(constants[1], constants[0])/(constants[2]-constants[3]) + computed_constants[92] = lt_func(constants[1], constants[0])/-constants[2] + computed_constants[93] = lt_func(constants[1], constants[0])/(constants[2]*constants[3]) + computed_constants[94] = lt_func(constants[1], constants[0])/(constants[2]/constants[3]) + computed_constants[95] = sqrt(constants[1]) + computed_constants[96] = pow(constants[1], 2.0) + computed_constants[97] = pow(constants[1], 3.0) + computed_constants[98] = pow(constants[1], constants[0]) + computed_constants[99] = pow(leq_func(constants[1], constants[0]), geq_func(constants[2], constants[3])) + computed_constants[100] = pow(constants[1]+constants[0], geq_func(constants[2], constants[3])) + computed_constants[101] = pow(constants[1], geq_func(constants[0], constants[2])) + computed_constants[102] = pow(constants[1]-constants[0], geq_func(constants[2], constants[3])) + computed_constants[103] = pow(-constants[1], geq_func(constants[0], constants[2])) + computed_constants[104] = pow(constants[1]*constants[0], geq_func(constants[2], constants[3])) + computed_constants[105] = pow(constants[1]/constants[0], geq_func(constants[2], constants[3])) + computed_constants[106] = pow(leq_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[107] = pow(leq_func(constants[1], constants[0]), constants[2]) + computed_constants[108] = pow(leq_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[109] = pow(leq_func(constants[1], constants[0]), -constants[2]) + computed_constants[110] = pow(leq_func(constants[1], constants[0]), constants[2]*constants[3]) + computed_constants[111] = pow(leq_func(constants[1], constants[0]), constants[2]/constants[3]) + computed_constants[112] = pow(leq_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[113] = pow(leq_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[114] = sqrt(constants[1]) + computed_constants[115] = sqrt(constants[1]) + computed_constants[116] = pow(constants[1], 1.0/3.0) + computed_constants[117] = pow(constants[1], 1.0/constants[0]) + computed_constants[118] = pow(lt_func(constants[1], constants[0]), 1.0/gt_func(constants[3], constants[2])) + computed_constants[119] = pow(constants[1]+constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[120] = pow(constants[1], 1.0/gt_func(constants[2], constants[0])) + computed_constants[121] = pow(constants[1]-constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[122] = pow(-constants[1], 1.0/gt_func(constants[2], constants[0])) + computed_constants[123] = pow(constants[1]*constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[124] = pow(constants[1]/constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[125] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]+constants[3])) + computed_constants[126] = pow(lt_func(constants[1], constants[0]), 1.0/constants[2]) + computed_constants[127] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]-constants[3])) + computed_constants[128] = pow(lt_func(constants[1], constants[0]), 1.0/-constants[2]) + computed_constants[129] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]*constants[3])) + computed_constants[130] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]/constants[3])) + computed_constants[131] = pow(lt_func(constants[1], constants[0]), 1.0/pow(constants[2], constants[3])) + computed_constants[132] = pow(lt_func(constants[1], constants[0]), 1.0/pow(constants[2], 1.0/constants[3])) + computed_constants[133] = fabs(constants[1]) + computed_constants[134] = exp(constants[1]) + computed_constants[135] = log(constants[1]) + computed_constants[136] = log10(constants[1]) + computed_constants[137] = log(constants[1])/log(2.0) + computed_constants[138] = log10(constants[1]) + computed_constants[139] = log(constants[1])/log(constants[0]) + computed_constants[140] = ceil(constants[1]) + computed_constants[141] = floor(constants[1]) + computed_constants[142] = min(constants[1], constants[0]) + computed_constants[143] = min(constants[1], min(constants[0], constants[2])) + computed_constants[144] = max(constants[1], constants[0]) + computed_constants[145] = max(constants[1], max(constants[0], constants[2])) + computed_constants[146] = fmod(constants[1], constants[0]) + computed_constants[147] = sin(constants[1]) + computed_constants[148] = cos(constants[1]) + computed_constants[149] = tan(constants[1]) + computed_constants[150] = sec(constants[1]) + computed_constants[151] = csc(constants[1]) + computed_constants[152] = cot(constants[1]) + computed_constants[153] = sinh(constants[1]) + computed_constants[154] = cosh(constants[1]) + computed_constants[155] = tanh(constants[1]) + computed_constants[156] = sech(constants[1]) + computed_constants[157] = csch(constants[1]) + computed_constants[158] = coth(constants[1]) + computed_constants[159] = asin(constants[1]) + computed_constants[160] = acos(constants[1]) + computed_constants[161] = atan(constants[1]) + computed_constants[162] = asec(constants[1]) + computed_constants[163] = acsc(constants[1]) + computed_constants[164] = acot(constants[1]) + computed_constants[165] = asinh(constants[1]) + computed_constants[166] = acosh(constants[1]) + computed_constants[167] = atanh(constants[1]/2.0) + computed_constants[168] = asech(constants[1]) + computed_constants[169] = acsch(constants[1]) + computed_constants[170] = acoth(2.0*constants[1]) + computed_constants[171] = constants[1] if gt_func(constants[1], constants[0]) else nan + computed_constants[172] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] + computed_constants[173] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan + computed_constants[174] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] + computed_constants[175] = 123.0+(constants[1] if gt_func(constants[1], constants[0]) else nan) + computed_constants[180] = constants[1] + computed_constants[187] = and_func(constants[1], constants[0])+(constants[0] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) + computed_constants[188] = and_func(constants[1], constants[0])-((constants[0] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[0] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) + computed_constants[189] = and_func(constants[1], constants[0])*(constants[0] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[0] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) + computed_constants[190] = and_func(constants[1], constants[0])/((constants[0] if gt_func(constants[2], constants[3]) else nan)/(constants[4]/(constants[0] if gt_func(constants[2], constants[3]) else nan))) + computed_constants[191] = and_func(or_func(constants[1], constants[0]), and_func(xor_func(constants[1], constants[0]), and_func(constants[0] if gt_func(constants[2], constants[3]) else nan, and_func(and_func(and_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[1], constants[0])), or_func(constants[1], constants[0]))))) + computed_constants[192] = or_func(and_func(constants[1], constants[0]), or_func(xor_func(constants[1], constants[0]), or_func(constants[0] if gt_func(constants[2], constants[3]) else nan, or_func(or_func(or_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[1], constants[0])), and_func(constants[1], constants[0]))))) + computed_constants[193] = xor_func(and_func(constants[1], constants[0]), xor_func(or_func(constants[1], constants[0]), xor_func(constants[0] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), or_func(constants[1], constants[0])), and_func(constants[1], constants[0]))))) + computed_constants[194] = pow(and_func(constants[1], constants[0]), pow(constants[0] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), and_func(constants[1], constants[0])))) + computed_constants[195] = pow(pow(pow(and_func(constants[1], constants[0]), 1.0/pow(constants[0] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[0] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[1], constants[0])) + computed_constants[196] = -and_func(constants[1], constants[0])-(constants[0] if gt_func(constants[2], constants[3]) else nan) + computed_constants[197] = computed_constants[199]+computed_constants[198] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + rates[0] = 1.0 + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile_windows.c similarity index 98% rename from tests/resources/coverage/generator/model.modified.profile.c rename to tests/resources/coverage/generator/model.modified.profile_windows.c index 36f0efe208..91a844acc5 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile_windows.c @@ -10,7 +10,7 @@ const char LIBCELLML_VERSION[] = "0.7.0"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 7; -const size_t COMPUTED_CONSTANT_COUNT = 199; +const size_t COMPUTED_CONSTANT_COUNT = 200; const size_t ALGEBRAIC_VARIABLE_COUNT = 2; const size_t EXTERNAL_VARIABLE_COUNT = 1; @@ -228,6 +228,7 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"eqnCoverageForPowerOperator", "dimensionless", "my_component"}, {"eqnCoverageForRootOperator", "dimensionless", "my_component"}, {"eqnCoverageForMinusUnary", "dimensionless", "my_component"}, + {"eqnComputedConstant3", "dimensionless", "my_component"}, {"eqnComputedConstant2", "dimensionless", "my_component"}, {"eqnComputedConstant1", "dimensionless", "my_component"} }; @@ -408,8 +409,8 @@ void objectiveFunction0(double *u, double *f, void *data) algebraicVariables[0] = u[0]; algebraicVariables[1] = u[1]; - f[0] = algebraicVariables[1]+algebraicVariables[0]+states[0]-0.0; - f[1] = algebraicVariables[1]-algebraicVariables[0]-(computedConstants[198]+computedConstants[197]); + f[0] = constants[1]+sin(algebraicVariables[1])+computedConstants[197]+states[0]+sin(algebraicVariables[0])-1.0; + f[1] = sin(algebraicVariables[1])-computedConstants[197]-computedConstants[198]-computedConstants[199]-sin(algebraicVariables[0])-0.5; } void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) @@ -446,10 +447,10 @@ void initialiseArrays(double *states, double *rates, double *constants, double * computedConstants[184] = 3.14159265358979; computedConstants[185] = INFINITY; computedConstants[186] = NAN; - computedConstants[198] = 1.0; - computedConstants[197] = 3.0; - algebraicVariables[0] = 2.0; - algebraicVariables[1] = 1.0; + computedConstants[199] = 1.0; + computedConstants[198] = 3.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; } void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) @@ -640,7 +641,8 @@ void computeComputedConstants(double voi, double *states, double *rates, double computedConstants[193] = xor(constants[1] && constants[0], xor(constants[1] || constants[0], xor((constants[2] > constants[3])?constants[0]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] || constants[0]), constants[1] && constants[0])))); computedConstants[194] = pow(constants[1] && constants[0], pow((constants[2] > constants[3])?constants[0]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] && constants[0]))); computedConstants[195] = pow(pow(pow(constants[1] && constants[0], 1.0/pow((constants[2] > constants[3])?constants[0]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[0]:NAN)), 1.0/(constants[1] && constants[0])); - computedConstants[196] = -(constants[1] && constants[0])+-((constants[2] > constants[3])?constants[0]:NAN); + computedConstants[196] = -(constants[1] && constants[0])-((constants[2] > constants[3])?constants[0]:NAN); + computedConstants[197] = computedConstants[199]+computedConstants[198]; } void computeRates(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_windows.py similarity index 98% rename from tests/resources/coverage/generator/model.modified.profile.py rename to tests/resources/coverage/generator/model.modified.profile_windows.py index 5b6f0496d6..15026731dc 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile_windows.py @@ -9,7 +9,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 7 -COMPUTED_CONSTANT_COUNT = 199 +COMPUTED_CONSTANT_COUNT = 200 ALGEBRAIC_VARIABLE_COUNT = 2 EXTERNAL_VARIABLE_COUNT = 1 @@ -227,6 +227,7 @@ {"name": "eqnCoverageForPowerOperator", "units": "dimensionless", "component": "my_component"}, {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component"}, {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant3", "units": "dimensionless", "component": "my_component"}, {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component"}, {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component"} ] @@ -378,8 +379,8 @@ def objective_function_0(u, f, data): algebraic_variables[0] = u[0] algebraic_variables[1] = u[1] - f[0] = algebraic_variables[1]+algebraic_variables[0]+states[0]-0.0 - f[1] = algebraic_variables[1]-algebraic_variables[0]-(computed_constants[198]+computed_constants[197]) + f[0] = constants[1]+sin(algebraic_variables[1])+computed_constants[197]+states[0]+sin(algebraic_variables[0])-1.0 + f[1] = sin(algebraic_variables[1])-computed_constants[197]-computed_constants[198]-computed_constants[199]-sin(algebraic_variables[0])-0.5 def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): @@ -413,10 +414,10 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va computed_constants[184] = 3.14159265358979 computed_constants[185] = inf computed_constants[186] = nan - computed_constants[198] = 1.0 - computed_constants[197] = 3.0 - algebraic_variables[0] = 2.0 - algebraic_variables[1] = 1.0 + computed_constants[199] = 1.0 + computed_constants[198] = 3.0 + algebraic_variables[0] = 0.0 + algebraic_variables[1] = 0.0 def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): @@ -606,7 +607,8 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants computed_constants[193] = xor_func(and_func(constants[1], constants[0]), xor_func(or_func(constants[1], constants[0]), xor_func(constants[0] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), or_func(constants[1], constants[0])), and_func(constants[1], constants[0]))))) computed_constants[194] = pow(and_func(constants[1], constants[0]), pow(constants[0] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), and_func(constants[1], constants[0])))) computed_constants[195] = pow(pow(pow(and_func(constants[1], constants[0]), 1.0/pow(constants[0] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[0] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[1], constants[0])) - computed_constants[196] = -and_func(constants[1], constants[0])+-(constants[0] if gt_func(constants[2], constants[3]) else nan) + computed_constants[196] = -and_func(constants[1], constants[0])-(constants[0] if gt_func(constants[2], constants[3]) else nan) + computed_constants[197] = computed_constants[199]+computed_constants[198] def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): diff --git a/tests/resources/coverage/generator/model.no.tracking.c b/tests/resources/coverage/generator/model.no.tracking_linux.c similarity index 86% rename from tests/resources/coverage/generator/model.no.tracking.c rename to tests/resources/coverage/generator/model.no.tracking_linux.c index 47a96ed108..46d019cfed 100644 --- a/tests/resources/coverage/generator/model.no.tracking.c +++ b/tests/resources/coverage/generator/model.no.tracking_linux.c @@ -184,8 +184,13 @@ void objectiveFunction0(double *u, double *f, void *data) algebraicVariables[0] = u[0]; algebraicVariables[1] = u[1]; - f[0] = algebraicVariables[1]+algebraicVariables[0]+states[0]-0.0; - f[1] = algebraicVariables[1]-algebraicVariables[0]-(my_component_eqnComputedConstant1+my_component_eqnComputedConstant2); + double my_component_m = 123.0; + double my_component_eqnComputedConstant1 = 1.0; + double my_component_eqnComputedConstant2 = 3.0; + double my_component_eqnComputedConstant3 = my_component_eqnComputedConstant1+my_component_eqnComputedConstant2; + + f[0] = sin(algebraicVariables[1])+sin(algebraicVariables[0])+states[0]+my_component_eqnComputedConstant3+my_component_m-1.0; + f[1] = -sin(algebraicVariables[0])+sin(algebraicVariables[1])-my_component_eqnComputedConstant1-my_component_eqnComputedConstant3-my_component_eqnComputedConstant2-0.5; } void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) @@ -205,20 +210,8 @@ void findRoot0(double voi, double *states, double *rates, double *constants, dou void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; - double my_component_eqnCnInteger = 123.0; - double my_component_eqnCnDouble = 123.456789; - double my_component_eqnCnIntegerWithExponent = 123.0e99; - double my_component_eqnCnDoubleWithExponent = 123.456789e99; - double my_component_eqnTrue = 1.0; - double my_component_eqnFalse = 0.0; - double my_component_eqnExponentiale = 2.71828182845905; - double my_component_eqnPi = 3.14159265358979; - double my_component_eqnInfinity = INFINITY; - double my_component_eqnNotanumber = NAN; - double my_component_eqnComputedConstant1 = 1.0; - double my_component_eqnComputedConstant2 = 3.0; - algebraicVariables[0] = 2.0; - algebraicVariables[1] = 1.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; } void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) diff --git a/tests/resources/coverage/generator/model.no.tracking_macos.c b/tests/resources/coverage/generator/model.no.tracking_macos.c new file mode 100644 index 0000000000..b3eff26de5 --- /dev/null +++ b/tests/resources/coverage/generator/model.no.tracking_macos.c @@ -0,0 +1,229 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; + +const VariableInfo VOI_INFO = {"t", "second", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"eqnNlaVariable2", "dimensionless", "my_component"}, + {"eqnNlaVariable1", "dimensionless", "my_component"} +}; + +double xor(double x, double y) +{ + return (x != 0.0) ^ (y != 0.0); +} + +double min(double x, double y) +{ + return (x < y)?x:y; +} + +double max(double x, double y) +{ + return (x > y)?x:y; +} + +double sec(double x) +{ + return 1.0/cos(x); +} + +double csc(double x) +{ + return 1.0/sin(x); +} + +double cot(double x) +{ + return 1.0/tan(x); +} + +double sech(double x) +{ + return 1.0/cosh(x); +} + +double csch(double x) +{ + return 1.0/sinh(x); +} + +double coth(double x) +{ + return 1.0/tanh(x); +} + +double asec(double x) +{ + return acos(1.0/x); +} + +double acsc(double x) +{ + return asin(1.0/x); +} + +double acot(double x) +{ + return atan(1.0/x); +} + +double asech(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX-1.0)); +} + +double acsch(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX+1.0)); +} + +double acoth(double x) +{ + double oneOverX = 1.0/x; + + return 0.5*log((1.0+oneOverX)/(1.0-oneOverX)); +} + +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]; + algebraicVariables[1] = u[1]; + + double my_component_m = 123.0; + double my_component_eqnComputedConstant1 = 1.0; + double my_component_eqnComputedConstant2 = 3.0; + double my_component_eqnComputedConstant3 = my_component_eqnComputedConstant1+my_component_eqnComputedConstant2; + + f[0] = sin(algebraicVariables[1])+sin(algebraicVariables[0])+states[0]+my_component_eqnComputedConstant3+my_component_m-1.0; + f[1] = -my_component_eqnComputedConstant3-sin(algebraicVariables[0])-my_component_eqnComputedConstant2-my_component_eqnComputedConstant1+sin(algebraicVariables[1])-0.5; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[2]; + + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; + + nlaSolve(objectiveFunction0, u, 2, &rfi); + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[0] = 1.0; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); +} diff --git a/tests/resources/coverage/generator/model.no.tracking_windows.c b/tests/resources/coverage/generator/model.no.tracking_windows.c new file mode 100644 index 0000000000..248a4eceff --- /dev/null +++ b/tests/resources/coverage/generator/model.no.tracking_windows.c @@ -0,0 +1,229 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; + +const VariableInfo VOI_INFO = {"t", "second", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"eqnNlaVariable2", "dimensionless", "my_component"}, + {"eqnNlaVariable1", "dimensionless", "my_component"} +}; + +double xor(double x, double y) +{ + return (x != 0.0) ^ (y != 0.0); +} + +double min(double x, double y) +{ + return (x < y)?x:y; +} + +double max(double x, double y) +{ + return (x > y)?x:y; +} + +double sec(double x) +{ + return 1.0/cos(x); +} + +double csc(double x) +{ + return 1.0/sin(x); +} + +double cot(double x) +{ + return 1.0/tan(x); +} + +double sech(double x) +{ + return 1.0/cosh(x); +} + +double csch(double x) +{ + return 1.0/sinh(x); +} + +double coth(double x) +{ + return 1.0/tanh(x); +} + +double asec(double x) +{ + return acos(1.0/x); +} + +double acsc(double x) +{ + return asin(1.0/x); +} + +double acot(double x) +{ + return atan(1.0/x); +} + +double asech(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX-1.0)); +} + +double acsch(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX+1.0)); +} + +double acoth(double x) +{ + double oneOverX = 1.0/x; + + return 0.5*log((1.0+oneOverX)/(1.0-oneOverX)); +} + +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]; + algebraicVariables[1] = u[1]; + + double my_component_m = 123.0; + double my_component_eqnComputedConstant1 = 1.0; + double my_component_eqnComputedConstant2 = 3.0; + double my_component_eqnComputedConstant3 = my_component_eqnComputedConstant1+my_component_eqnComputedConstant2; + + f[0] = my_component_m+sin(algebraicVariables[1])+my_component_eqnComputedConstant3+states[0]+sin(algebraicVariables[0])-1.0; + f[1] = sin(algebraicVariables[1])-my_component_eqnComputedConstant3-my_component_eqnComputedConstant2-my_component_eqnComputedConstant1-sin(algebraicVariables[0])-0.5; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[2]; + + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; + + nlaSolve(objectiveFunction0, u, 2, &rfi); + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[0] = 1.0; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); +} diff --git a/tests/resources/coverage/generator/model_linux.c b/tests/resources/coverage/generator/model_linux.c new file mode 100644 index 0000000000..a381721c65 --- /dev/null +++ b/tests/resources/coverage/generator/model_linux.c @@ -0,0 +1,657 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 1; +const size_t CONSTANT_COUNT = 7; +const size_t COMPUTED_CONSTANT_COUNT = 200; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"t", "second", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"n", "dimensionless", "my_component"}, + {"m", "dimensionless", "my_component"}, + {"o", "dimensionless", "my_component"}, + {"p", "dimensionless", "my_component"}, + {"q", "dimensionless", "my_component"}, + {"r", "dimensionless", "my_component"}, + {"s", "dimensionless", "my_component"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"eqnEq", "dimensionless", "my_component"}, + {"eqnEqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnNeq", "dimensionless", "my_component"}, + {"eqnNeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnLt", "dimensionless", "my_component"}, + {"eqnLtCoverageParentheses", "dimensionless", "my_component"}, + {"eqnLeq", "dimensionless", "my_component"}, + {"eqnLeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnGt", "dimensionless", "my_component"}, + {"eqnGtCoverageParentheses", "dimensionless", "my_component"}, + {"eqnGeq", "dimensionless", "my_component"}, + {"eqnGeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnAnd", "dimensionless", "my_component"}, + {"eqnAndMultiple", "dimensionless", "my_component"}, + {"eqnAndParentheses", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnAndCoverageParentheses", "dimensionless", "my_component"}, + {"eqnOr", "dimensionless", "my_component"}, + {"eqnOrMultiple", "dimensionless", "my_component"}, + {"eqnOrParentheses", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnOrCoverageParentheses", "dimensionless", "my_component"}, + {"eqnXor", "dimensionless", "my_component"}, + {"eqnXorMultiple", "dimensionless", "my_component"}, + {"eqnXorParentheses", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnXorCoverageParentheses", "dimensionless", "my_component"}, + {"eqnNot", "dimensionless", "my_component"}, + {"eqnPlusMultiple", "dimensionless", "my_component"}, + {"eqnPlusParentheses", "dimensionless", "my_component"}, + {"eqnPlusUnary", "dimensionless", "my_component"}, + {"eqnMinus", "dimensionless", "my_component"}, + {"eqnMinusParentheses", "dimensionless", "my_component"}, + {"eqnMinusParenthesesPlusWith", "dimensionless", "my_component"}, + {"eqnMinusParenthesesPlusWithout", "dimensionless", "my_component"}, + {"eqnMinusParenthesesDirectUnaryMinus", "dimensionless", "my_component"}, + {"eqnMinusParenthesesIndirectUnaryMinus", "dimensionless", "my_component"}, + {"eqnMinusUnary", "dimensionless", "my_component"}, + {"eqnMinusUnaryParentheses", "dimensionless", "my_component"}, + {"eqnTimes", "dimensionless", "my_component"}, + {"eqnTimesMultiple", "dimensionless", "my_component"}, + {"eqnTimesParentheses", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnDivide", "dimensionless", "my_component"}, + {"eqnDivideParentheses", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnPowerSqrt", "dimensionless", "my_component"}, + {"eqnPowerSqr", "dimensionless", "my_component"}, + {"eqnPowerCube", "dimensionless", "my_component"}, + {"eqnPowerCi", "dimensionless", "my_component"}, + {"eqnPowerParentheses", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftTimes", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftDivide", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnRootSqrt", "dimensionless", "my_component"}, + {"eqnRootSqrtOther", "dimensionless", "my_component"}, + {"eqnRootCube", "dimensionless", "my_component"}, + {"eqnRootCi", "dimensionless", "my_component"}, + {"eqnRootParentheses", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftTimes", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftDivide", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnAbs", "dimensionless", "my_component"}, + {"eqnExp", "dimensionless", "my_component"}, + {"eqnLn", "dimensionless", "my_component"}, + {"eqnLog", "dimensionless", "my_component"}, + {"eqnLog2", "dimensionless", "my_component"}, + {"eqnLog10", "dimensionless", "my_component"}, + {"eqnLogCi", "dimensionless", "my_component"}, + {"eqnCeiling", "dimensionless", "my_component"}, + {"eqnFloor", "dimensionless", "my_component"}, + {"eqnMin", "dimensionless", "my_component"}, + {"eqnMinMultiple", "dimensionless", "my_component"}, + {"eqnMax", "dimensionless", "my_component"}, + {"eqnMaxMultiple", "dimensionless", "my_component"}, + {"eqnRem", "dimensionless", "my_component"}, + {"eqnSin", "dimensionless", "my_component"}, + {"eqnCos", "dimensionless", "my_component"}, + {"eqnTan", "dimensionless", "my_component"}, + {"eqnSec", "dimensionless", "my_component"}, + {"eqnCsc", "dimensionless", "my_component"}, + {"eqnCot", "dimensionless", "my_component"}, + {"eqnSinh", "dimensionless", "my_component"}, + {"eqnCosh", "dimensionless", "my_component"}, + {"eqnTanh", "dimensionless", "my_component"}, + {"eqnSech", "dimensionless", "my_component"}, + {"eqnCsch", "dimensionless", "my_component"}, + {"eqnCoth", "dimensionless", "my_component"}, + {"eqnArcsin", "dimensionless", "my_component"}, + {"eqnArccos", "dimensionless", "my_component"}, + {"eqnArctan", "dimensionless", "my_component"}, + {"eqnArcsec", "dimensionless", "my_component"}, + {"eqnArccsc", "dimensionless", "my_component"}, + {"eqnArccot", "dimensionless", "my_component"}, + {"eqnArcsinh", "dimensionless", "my_component"}, + {"eqnArccosh", "dimensionless", "my_component"}, + {"eqnArctanh", "dimensionless", "my_component"}, + {"eqnArcsech", "dimensionless", "my_component"}, + {"eqnArccsch", "dimensionless", "my_component"}, + {"eqnArccoth", "dimensionless", "my_component"}, + {"eqnPiecewisePiece", "dimensionless", "my_component"}, + {"eqnPiecewisePieceOtherwise", "dimensionless", "my_component"}, + {"eqnPiecewisePiecePiecePiece", "dimensionless", "my_component"}, + {"eqnPiecewisePiecePiecePieceOtherwise", "dimensionless", "my_component"}, + {"eqnWithPiecewise", "dimensionless", "my_component"}, + {"eqnCnInteger", "dimensionless", "my_component"}, + {"eqnCnDouble", "dimensionless", "my_component"}, + {"eqnCnIntegerWithExponent", "dimensionless", "my_component"}, + {"eqnCnDoubleWithExponent", "dimensionless", "my_component"}, + {"eqnCi", "dimensionless", "my_component"}, + {"eqnTrue", "dimensionless", "my_component"}, + {"eqnFalse", "dimensionless", "my_component"}, + {"eqnExponentiale", "dimensionless", "my_component"}, + {"eqnPi", "dimensionless", "my_component"}, + {"eqnInfinity", "dimensionless", "my_component"}, + {"eqnNotanumber", "dimensionless", "my_component"}, + {"eqnCoverageForPlusOperator", "dimensionless", "my_component"}, + {"eqnCoverageForMinusOperator", "dimensionless", "my_component"}, + {"eqnCoverageForTimesOperator", "dimensionless", "my_component"}, + {"eqnCoverageForDivideOperator", "dimensionless", "my_component"}, + {"eqnCoverageForAndOperator", "dimensionless", "my_component"}, + {"eqnCoverageForOrOperator", "dimensionless", "my_component"}, + {"eqnCoverageForXorOperator", "dimensionless", "my_component"}, + {"eqnCoverageForPowerOperator", "dimensionless", "my_component"}, + {"eqnCoverageForRootOperator", "dimensionless", "my_component"}, + {"eqnCoverageForMinusUnary", "dimensionless", "my_component"}, + {"eqnComputedConstant3", "dimensionless", "my_component"}, + {"eqnComputedConstant2", "dimensionless", "my_component"}, + {"eqnComputedConstant1", "dimensionless", "my_component"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"eqnNlaVariable2", "dimensionless", "my_component"}, + {"eqnNlaVariable1", "dimensionless", "my_component"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"eqnPlus", "dimensionless", "my_component"} +}; + +double xor(double x, double y) +{ + return (x != 0.0) ^ (y != 0.0); +} + +double min(double x, double y) +{ + return (x < y)?x:y; +} + +double max(double x, double y) +{ + return (x > y)?x:y; +} + +double sec(double x) +{ + return 1.0/cos(x); +} + +double csc(double x) +{ + return 1.0/sin(x); +} + +double cot(double x) +{ + return 1.0/tan(x); +} + +double sech(double x) +{ + return 1.0/cosh(x); +} + +double csch(double x) +{ + return 1.0/sinh(x); +} + +double coth(double x) +{ + return 1.0/tanh(x); +} + +double asec(double x) +{ + return acos(1.0/x); +} + +double acsc(double x) +{ + return asin(1.0/x); +} + +double acot(double x) +{ + return atan(1.0/x); +} + +double asech(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX-1.0)); +} + +double acsch(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX+1.0)); +} + +double acoth(double x) +{ + double oneOverX = 1.0/x; + + return 0.5*log((1.0+oneOverX)/(1.0-oneOverX)); +} + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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; + double *externalVariables; +} 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; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; + + f[0] = sin(algebraicVariables[1])+sin(algebraicVariables[0])+states[0]+computedConstants[197]+constants[1]-1.0; + f[1] = -sin(algebraicVariables[0])+sin(algebraicVariables[1])-computedConstants[199]-computedConstants[197]-computedConstants[198]-0.5; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; + double u[2]; + + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; + + nlaSolve(objectiveFunction0, u, 2, &rfi); + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + constants[0] = 1.23; + constants[1] = 123.0; + constants[2] = 1.0e1; + constants[3] = 1.23e1; + constants[4] = 1.0E1; + constants[5] = 1.23E1; + constants[6] = 7.0; + computedConstants[176] = 123.0; + computedConstants[177] = 123.456789; + computedConstants[178] = 123.0e99; + computedConstants[179] = 123.456789e99; + computedConstants[181] = 1.0; + computedConstants[182] = 0.0; + computedConstants[183] = 2.71828182845905; + computedConstants[184] = 3.14159265358979; + computedConstants[185] = INFINITY; + computedConstants[186] = NAN; + computedConstants[199] = 1.0; + computedConstants[198] = 3.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[1] == constants[0]; + computedConstants[1] = constants[1]/(constants[0] == constants[0]); + computedConstants[2] = constants[1] != constants[0]; + computedConstants[3] = constants[1]/(constants[0] != constants[2]); + computedConstants[4] = constants[1] < constants[0]; + computedConstants[5] = constants[1]/(constants[0] < constants[2]); + computedConstants[6] = constants[1] <= constants[0]; + computedConstants[7] = constants[1]/(constants[0] <= constants[2]); + computedConstants[8] = constants[1] > constants[0]; + computedConstants[9] = constants[1]/(constants[0] > constants[2]); + computedConstants[10] = constants[1] >= constants[0]; + computedConstants[11] = constants[1]/(constants[0] >= constants[2]); + computedConstants[12] = constants[1] && constants[0]; + computedConstants[13] = constants[1] && constants[0] && constants[2]; + computedConstants[14] = (constants[1] < constants[0]) && (constants[2] > constants[3]); + computedConstants[15] = (constants[1]+constants[0]) && (constants[2] > constants[3]); + computedConstants[16] = constants[1] && (constants[0] > constants[2]); + computedConstants[17] = (constants[1]-constants[0]) && (constants[2] > constants[3]); + computedConstants[18] = -constants[1] && (constants[0] > constants[2]); + computedConstants[19] = pow(constants[1], constants[0]) && (constants[2] > constants[3]); + computedConstants[20] = pow(constants[1], 1.0/constants[0]) && (constants[2] > constants[3]); + computedConstants[21] = (constants[1] < constants[0]) && (constants[2]+constants[3]); + computedConstants[22] = (constants[1] < constants[0]) && constants[2]; + computedConstants[23] = (constants[1] < constants[0]) && (constants[2]-constants[3]); + computedConstants[24] = (constants[1] < constants[0]) && -constants[2]; + computedConstants[25] = (constants[1] < constants[0]) && pow(constants[2], constants[3]); + computedConstants[26] = (constants[1] < constants[0]) && pow(constants[2], 1.0/constants[3]); + computedConstants[27] = constants[1]/(constants[0] && constants[2]); + computedConstants[28] = constants[1] || constants[0]; + computedConstants[29] = constants[1] || constants[0] || constants[2]; + computedConstants[30] = (constants[1] < constants[0]) || (constants[2] > constants[3]); + computedConstants[31] = (constants[1]+constants[0]) || (constants[2] > constants[3]); + computedConstants[32] = constants[1] || (constants[0] > constants[2]); + computedConstants[33] = (constants[1]-constants[0]) || (constants[2] > constants[3]); + computedConstants[34] = -constants[1] || (constants[0] > constants[2]); + computedConstants[35] = pow(constants[1], constants[0]) || (constants[2] > constants[3]); + computedConstants[36] = pow(constants[1], 1.0/constants[0]) || (constants[2] > constants[3]); + computedConstants[37] = (constants[1] < constants[0]) || (constants[2]+constants[3]); + computedConstants[38] = (constants[1] < constants[0]) || constants[2]; + computedConstants[39] = (constants[1] < constants[0]) || (constants[2]-constants[3]); + computedConstants[40] = (constants[1] < constants[0]) || -constants[2]; + computedConstants[41] = (constants[1] < constants[0]) || pow(constants[2], constants[3]); + computedConstants[42] = (constants[1] < constants[0]) || pow(constants[2], 1.0/constants[3]); + computedConstants[43] = constants[1]/(constants[0] || constants[2]); + computedConstants[44] = xor(constants[1], constants[0]); + computedConstants[45] = xor(constants[1], xor(constants[0], constants[2])); + computedConstants[46] = xor(constants[1] < constants[0], constants[2] > constants[3]); + computedConstants[47] = xor(constants[1]+constants[0], constants[2] > constants[3]); + computedConstants[48] = xor(constants[1], constants[0] > constants[2]); + computedConstants[49] = xor(constants[1]-constants[0], constants[2] > constants[3]); + computedConstants[50] = xor(-constants[1], constants[0] > constants[2]); + computedConstants[51] = xor(pow(constants[1], constants[0]), constants[2] > constants[3]); + computedConstants[52] = xor(pow(constants[1], 1.0/constants[0]), constants[2] > constants[3]); + computedConstants[53] = xor(constants[1] < constants[0], constants[2]+constants[3]); + computedConstants[54] = xor(constants[1] < constants[0], constants[2]); + computedConstants[55] = xor(constants[1] < constants[0], constants[2]-constants[3]); + computedConstants[56] = xor(constants[1] < constants[0], -constants[2]); + computedConstants[57] = xor(constants[1] < constants[0], pow(constants[2], constants[3])); + computedConstants[58] = xor(constants[1] < constants[0], pow(constants[2], 1.0/constants[3])); + computedConstants[59] = constants[1]/xor(constants[0], constants[2]); + computedConstants[60] = !constants[1]; + computedConstants[61] = constants[1]+constants[0]+constants[2]; + computedConstants[62] = (constants[1] < constants[0])+(constants[2] > constants[3]); + computedConstants[63] = constants[1]; + computedConstants[64] = constants[1]-constants[0]; + computedConstants[65] = (constants[1] < constants[0])-(constants[2] > constants[3]); + computedConstants[66] = (constants[1] < constants[0])-(constants[2]+constants[3]); + computedConstants[67] = (constants[1] < constants[0])-constants[2]; + computedConstants[68] = constants[1]-(-constants[0]); + computedConstants[69] = constants[1]-(-constants[0]*constants[2]); + computedConstants[70] = -constants[1]; + computedConstants[71] = -(constants[1] < constants[0]); + computedConstants[72] = constants[1]*constants[0]; + computedConstants[73] = constants[1]*constants[0]*constants[2]; + computedConstants[74] = (constants[1] < constants[0])*(constants[2] > constants[3]); + computedConstants[75] = (constants[1]+constants[0])*(constants[2] > constants[3]); + computedConstants[76] = constants[1]*(constants[0] > constants[2]); + computedConstants[77] = (constants[1]-constants[0])*(constants[2] > constants[3]); + computedConstants[78] = -constants[1]*(constants[0] > constants[2]); + computedConstants[79] = (constants[1] < constants[0])*(constants[2]+constants[3]); + computedConstants[80] = (constants[1] < constants[0])*constants[2]; + computedConstants[81] = (constants[1] < constants[0])*(constants[2]-constants[3]); + computedConstants[82] = (constants[1] < constants[0])*-constants[2]; + computedConstants[83] = constants[1]/constants[0]; + computedConstants[84] = (constants[1] < constants[0])/(constants[3] > constants[2]); + computedConstants[85] = (constants[1]+constants[0])/(constants[3] > constants[2]); + computedConstants[86] = constants[1]/(constants[2] > constants[0]); + computedConstants[87] = (constants[1]-constants[0])/(constants[3] > constants[2]); + computedConstants[88] = -constants[1]/(constants[2] > constants[0]); + computedConstants[89] = (constants[1] < constants[0])/(constants[2]+constants[3]); + computedConstants[90] = (constants[1] < constants[0])/constants[2]; + computedConstants[91] = (constants[1] < constants[0])/(constants[2]-constants[3]); + computedConstants[92] = (constants[1] < constants[0])/-constants[2]; + computedConstants[93] = (constants[1] < constants[0])/(constants[2]*constants[3]); + computedConstants[94] = (constants[1] < constants[0])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[1]); + computedConstants[96] = pow(constants[1], 2.0); + computedConstants[97] = pow(constants[1], 3.0); + computedConstants[98] = pow(constants[1], constants[0]); + computedConstants[99] = pow(constants[1] <= constants[0], constants[2] >= constants[3]); + computedConstants[100] = pow(constants[1]+constants[0], constants[2] >= constants[3]); + computedConstants[101] = pow(constants[1], constants[0] >= constants[2]); + computedConstants[102] = pow(constants[1]-constants[0], constants[2] >= constants[3]); + computedConstants[103] = pow(-constants[1], constants[0] >= constants[2]); + computedConstants[104] = pow(constants[1]*constants[0], constants[2] >= constants[3]); + computedConstants[105] = pow(constants[1]/constants[0], constants[2] >= constants[3]); + computedConstants[106] = pow(constants[1] <= constants[0], constants[2]+constants[3]); + computedConstants[107] = pow(constants[1] <= constants[0], constants[2]); + computedConstants[108] = pow(constants[1] <= constants[0], constants[2]-constants[3]); + computedConstants[109] = pow(constants[1] <= constants[0], -constants[2]); + computedConstants[110] = pow(constants[1] <= constants[0], constants[2]*constants[3]); + computedConstants[111] = pow(constants[1] <= constants[0], constants[2]/constants[3]); + computedConstants[112] = pow(constants[1] <= constants[0], pow(constants[2], constants[3])); + computedConstants[113] = pow(constants[1] <= constants[0], pow(constants[2], 1.0/constants[3])); + computedConstants[114] = sqrt(constants[1]); + computedConstants[115] = sqrt(constants[1]); + computedConstants[116] = pow(constants[1], 1.0/3.0); + computedConstants[117] = pow(constants[1], 1.0/constants[0]); + computedConstants[118] = pow(constants[1] < constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[119] = pow(constants[1]+constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[120] = pow(constants[1], 1.0/(constants[2] > constants[0])); + computedConstants[121] = pow(constants[1]-constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[122] = pow(-constants[1], 1.0/(constants[2] > constants[0])); + computedConstants[123] = pow(constants[1]*constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[124] = pow(constants[1]/constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[125] = pow(constants[1] < constants[0], 1.0/(constants[2]+constants[3])); + computedConstants[126] = pow(constants[1] < constants[0], 1.0/constants[2]); + computedConstants[127] = pow(constants[1] < constants[0], 1.0/(constants[2]-constants[3])); + computedConstants[128] = pow(constants[1] < constants[0], 1.0/-constants[2]); + computedConstants[129] = pow(constants[1] < constants[0], 1.0/(constants[2]*constants[3])); + computedConstants[130] = pow(constants[1] < constants[0], 1.0/(constants[2]/constants[3])); + computedConstants[131] = pow(constants[1] < constants[0], 1.0/pow(constants[2], constants[3])); + computedConstants[132] = pow(constants[1] < constants[0], 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[133] = fabs(constants[1]); + computedConstants[134] = exp(constants[1]); + computedConstants[135] = log(constants[1]); + computedConstants[136] = log10(constants[1]); + computedConstants[137] = log(constants[1])/log(2.0); + computedConstants[138] = log10(constants[1]); + computedConstants[139] = log(constants[1])/log(constants[0]); + computedConstants[140] = ceil(constants[1]); + computedConstants[141] = floor(constants[1]); + computedConstants[142] = min(constants[1], constants[0]); + computedConstants[143] = min(constants[1], min(constants[0], constants[2])); + computedConstants[144] = max(constants[1], constants[0]); + computedConstants[145] = max(constants[1], max(constants[0], constants[2])); + computedConstants[146] = fmod(constants[1], constants[0]); + computedConstants[147] = sin(constants[1]); + computedConstants[148] = cos(constants[1]); + computedConstants[149] = tan(constants[1]); + computedConstants[150] = sec(constants[1]); + computedConstants[151] = csc(constants[1]); + computedConstants[152] = cot(constants[1]); + computedConstants[153] = sinh(constants[1]); + computedConstants[154] = cosh(constants[1]); + computedConstants[155] = tanh(constants[1]); + computedConstants[156] = sech(constants[1]); + computedConstants[157] = csch(constants[1]); + computedConstants[158] = coth(constants[1]); + computedConstants[159] = asin(constants[1]); + computedConstants[160] = acos(constants[1]); + computedConstants[161] = atan(constants[1]); + computedConstants[162] = asec(constants[1]); + computedConstants[163] = acsc(constants[1]); + computedConstants[164] = acot(constants[1]); + computedConstants[165] = asinh(constants[1]); + computedConstants[166] = acosh(constants[1]); + computedConstants[167] = atanh(constants[1]/2.0); + computedConstants[168] = asech(constants[1]); + computedConstants[169] = acsch(constants[1]); + computedConstants[170] = acoth(2.0*constants[1]); + computedConstants[171] = (constants[1] > constants[0])?constants[1]:NAN; + computedConstants[172] = (constants[1] > constants[0])?constants[1]:constants[2]; + computedConstants[173] = (constants[1] > constants[0])?constants[1]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; + computedConstants[174] = (constants[1] > constants[0])?constants[1]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; + computedConstants[175] = 123.0+((constants[1] > constants[0])?constants[1]:NAN); + computedConstants[180] = constants[1]; + computedConstants[187] = (constants[1] && constants[0])+((constants[2] > constants[3])?constants[0]:NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[188] = (constants[1] && constants[0])-(((constants[2] > constants[3])?constants[0]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[0]:NAN)))-(constants[5] && constants[6]); + computedConstants[189] = (constants[1] && constants[0])*((constants[2] > constants[3])?constants[0]:NAN)*constants[4]*((constants[2] > constants[3])?constants[0]:NAN)*(constants[5] && constants[6]); + computedConstants[190] = (constants[1] && constants[0])/(((constants[2] > constants[3])?constants[0]:NAN)/(constants[4]/((constants[2] > constants[3])?constants[0]:NAN))); + computedConstants[191] = (constants[1] || constants[0]) && xor(constants[1], constants[0]) && ((constants[2] > constants[3])?constants[0]:NAN) && constants[4] && ((constants[2] > constants[3])?constants[0]:NAN) && xor(constants[1], constants[0]) && (constants[1] || constants[0]); + computedConstants[192] = (constants[1] && constants[0]) || xor(constants[1], constants[0]) || ((constants[2] > constants[3])?constants[0]:NAN) || constants[4] || ((constants[2] > constants[3])?constants[0]:NAN) || xor(constants[1], constants[0]) || (constants[1] && constants[0]); + computedConstants[193] = xor(constants[1] && constants[0], xor(constants[1] || constants[0], xor((constants[2] > constants[3])?constants[0]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] || constants[0]), constants[1] && constants[0])))); + computedConstants[194] = pow(constants[1] && constants[0], pow((constants[2] > constants[3])?constants[0]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] && constants[0]))); + computedConstants[195] = pow(pow(pow(constants[1] && constants[0], 1.0/pow((constants[2] > constants[3])?constants[0]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[0]:NAN)), 1.0/(constants[1] && constants[0])); + computedConstants[196] = -(constants[1] && constants[0])-((constants[2] > constants[3])?constants[0]:NAN); + computedConstants[197] = computedConstants[199]+computedConstants[198]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + rates[0] = 1.0; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); +} diff --git a/tests/resources/coverage/generator/model_linux.out b/tests/resources/coverage/generator/model_linux.out new file mode 100644 index 0000000000..4641f48d88 --- /dev/null +++ b/tests/resources/coverage/generator/model_linux.out @@ -0,0 +1,320 @@ +/* The content of this file was generated using a modified C profile of libCellML 0.7.0. */ + +#include "customheaderfile.h" + +double min(double x, double y) +{ + return (x < y)?x:y; +} + +double max(double x, double y) +{ + return (x > y)?x:y; +} + +double sec(double x) +{ + return 1.0/cos(x); +} + +double csc(double x) +{ + return 1.0/sin(x); +} + +double cot(double x) +{ + return 1.0/tan(x); +} + +double sech(double x) +{ + return 1.0/cosh(x); +} + +double csch(double x) +{ + return 1.0/sinh(x); +} + +double coth(double x) +{ + return 1.0/tanh(x); +} + +double asec(double x) +{ + return acos(1.0/x); +} + +double acsc(double x) +{ + return asin(1.0/x); +} + +double acot(double x) +{ + return atan(1.0/x); +} + +double asech(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX-1.0)); +} + +double acsch(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX+1.0)); +} + +double acoth(double x) +{ + double oneOverX = 1.0/x; + + return 0.5*log((1.0+oneOverX)/(1.0-oneOverX)); +} + +typedef struct { + double voi; + double *states; + double *rates; + double *constants; + double *computedConstants; + double *algebraicVariables; + double *externalVariables; +} 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; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; + + f[0] = sin(algebraicVariables[1])+sin(algebraicVariables[0])+states[0]+computedConstants[197]+constants[1]-1.0; + f[1] = -sin(algebraicVariables[0])+sin(algebraicVariables[1])-computedConstants[199]-computedConstants[197]-computedConstants[198]-0.5; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; + double u[2]; + + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; + + nlaSolve(objectiveFunction0, u, 2, &rfi); + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[1] == constants[0]; + computedConstants[1] = constants[1]/(constants[0] == constants[0]); + computedConstants[2] = constants[1] != constants[0]; + computedConstants[3] = constants[1]/(constants[0] != constants[2]); + computedConstants[4] = constants[1] < constants[0]; + computedConstants[5] = constants[1]/(constants[0] < constants[2]); + computedConstants[6] = constants[1] <= constants[0]; + computedConstants[7] = constants[1]/(constants[0] <= constants[2]); + computedConstants[8] = constants[1] > constants[0]; + computedConstants[9] = constants[1]/(constants[0] > constants[2]); + computedConstants[10] = constants[1] >= constants[0]; + computedConstants[11] = constants[1]/(constants[0] >= constants[2]); + computedConstants[12] = constants[1] && constants[0]; + computedConstants[13] = constants[1] && constants[0] && constants[2]; + computedConstants[14] = (constants[1] < constants[0]) && (constants[2] > constants[3]); + computedConstants[15] = (constants[1]+constants[0]) && (constants[2] > constants[3]); + computedConstants[16] = constants[1] && (constants[0] > constants[2]); + computedConstants[17] = (constants[1]-constants[0]) && (constants[2] > constants[3]); + computedConstants[18] = -constants[1] && (constants[0] > constants[2]); + computedConstants[19] = (constants[1]^^constants[0]) && (constants[2] > constants[3]); + computedConstants[20] = (constants[1]^^(1.0/constants[0])) && (constants[2] > constants[3]); + computedConstants[21] = (constants[1] < constants[0]) && (constants[2]+constants[3]); + computedConstants[22] = (constants[1] < constants[0]) && constants[2]; + computedConstants[23] = (constants[1] < constants[0]) && (constants[2]-constants[3]); + computedConstants[24] = (constants[1] < constants[0]) && -constants[2]; + computedConstants[25] = (constants[1] < constants[0]) && (constants[2]^^constants[3]); + computedConstants[26] = (constants[1] < constants[0]) && (constants[2]^^(1.0/constants[3])); + computedConstants[27] = constants[1]/(constants[0] && constants[2]); + computedConstants[28] = constants[1] || constants[0]; + computedConstants[29] = constants[1] || constants[0] || constants[2]; + computedConstants[30] = (constants[1] < constants[0]) || (constants[2] > constants[3]); + computedConstants[31] = (constants[1]+constants[0]) || (constants[2] > constants[3]); + computedConstants[32] = constants[1] || (constants[0] > constants[2]); + computedConstants[33] = (constants[1]-constants[0]) || (constants[2] > constants[3]); + computedConstants[34] = -constants[1] || (constants[0] > constants[2]); + computedConstants[35] = (constants[1]^^constants[0]) || (constants[2] > constants[3]); + computedConstants[36] = (constants[1]^^(1.0/constants[0])) || (constants[2] > constants[3]); + computedConstants[37] = (constants[1] < constants[0]) || (constants[2]+constants[3]); + computedConstants[38] = (constants[1] < constants[0]) || constants[2]; + computedConstants[39] = (constants[1] < constants[0]) || (constants[2]-constants[3]); + computedConstants[40] = (constants[1] < constants[0]) || -constants[2]; + computedConstants[41] = (constants[1] < constants[0]) || (constants[2]^^constants[3]); + computedConstants[42] = (constants[1] < constants[0]) || (constants[2]^^(1.0/constants[3])); + computedConstants[43] = constants[1]/(constants[0] || constants[2]); + computedConstants[44] = constants[1]^constants[0]; + computedConstants[45] = constants[1]^constants[0]^constants[2]; + computedConstants[46] = (constants[1] < constants[0])^(constants[2] > constants[3]); + computedConstants[47] = (constants[1]+constants[0])^(constants[2] > constants[3]); + computedConstants[48] = constants[1]^(constants[0] > constants[2]); + computedConstants[49] = (constants[1]-constants[0])^(constants[2] > constants[3]); + computedConstants[50] = -constants[1]^(constants[0] > constants[2]); + computedConstants[51] = (constants[1]^^constants[0])^(constants[2] > constants[3]); + computedConstants[52] = (constants[1]^^(1.0/constants[0]))^(constants[2] > constants[3]); + computedConstants[53] = (constants[1] < constants[0])^(constants[2]+constants[3]); + computedConstants[54] = (constants[1] < constants[0])^constants[2]; + computedConstants[55] = (constants[1] < constants[0])^(constants[2]-constants[3]); + computedConstants[56] = (constants[1] < constants[0])^-constants[2]; + computedConstants[57] = (constants[1] < constants[0])^(constants[2]^^constants[3]); + computedConstants[58] = (constants[1] < constants[0])^(constants[2]^^(1.0/constants[3])); + computedConstants[59] = constants[1]/(constants[0]^constants[2]); + computedConstants[60] = !constants[1]; + computedConstants[61] = constants[1]+constants[0]+constants[2]; + computedConstants[62] = (constants[1] < constants[0])+(constants[2] > constants[3]); + computedConstants[63] = constants[1]; + computedConstants[64] = constants[1]-constants[0]; + computedConstants[65] = (constants[1] < constants[0])-(constants[2] > constants[3]); + computedConstants[66] = (constants[1] < constants[0])-(constants[2]+constants[3]); + computedConstants[67] = (constants[1] < constants[0])-constants[2]; + computedConstants[68] = constants[1]-(-constants[0]); + computedConstants[69] = constants[1]-(-constants[0]*constants[2]); + computedConstants[70] = -constants[1]; + computedConstants[71] = -(constants[1] < constants[0]); + computedConstants[72] = constants[1]*constants[0]; + computedConstants[73] = constants[1]*constants[0]*constants[2]; + computedConstants[74] = (constants[1] < constants[0])*(constants[2] > constants[3]); + computedConstants[75] = (constants[1]+constants[0])*(constants[2] > constants[3]); + computedConstants[76] = constants[1]*(constants[0] > constants[2]); + computedConstants[77] = (constants[1]-constants[0])*(constants[2] > constants[3]); + computedConstants[78] = -constants[1]*(constants[0] > constants[2]); + computedConstants[79] = (constants[1] < constants[0])*(constants[2]+constants[3]); + computedConstants[80] = (constants[1] < constants[0])*constants[2]; + computedConstants[81] = (constants[1] < constants[0])*(constants[2]-constants[3]); + computedConstants[82] = (constants[1] < constants[0])*-constants[2]; + computedConstants[83] = constants[1]/constants[0]; + computedConstants[84] = (constants[1] < constants[0])/(constants[3] > constants[2]); + computedConstants[85] = (constants[1]+constants[0])/(constants[3] > constants[2]); + computedConstants[86] = constants[1]/(constants[2] > constants[0]); + computedConstants[87] = (constants[1]-constants[0])/(constants[3] > constants[2]); + computedConstants[88] = -constants[1]/(constants[2] > constants[0]); + computedConstants[89] = (constants[1] < constants[0])/(constants[2]+constants[3]); + computedConstants[90] = (constants[1] < constants[0])/constants[2]; + computedConstants[91] = (constants[1] < constants[0])/(constants[2]-constants[3]); + computedConstants[92] = (constants[1] < constants[0])/-constants[2]; + computedConstants[93] = (constants[1] < constants[0])/(constants[2]*constants[3]); + computedConstants[94] = (constants[1] < constants[0])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[1]); + computedConstants[96] = sqr(constants[1]); + computedConstants[97] = constants[1]^^3.0; + computedConstants[98] = constants[1]^^constants[0]; + computedConstants[99] = (constants[1] <= constants[0])^^(constants[2] >= constants[3]); + computedConstants[100] = (constants[1]+constants[0])^^(constants[2] >= constants[3]); + computedConstants[101] = constants[1]^^(constants[0] >= constants[2]); + computedConstants[102] = (constants[1]-constants[0])^^(constants[2] >= constants[3]); + computedConstants[103] = (-constants[1])^^(constants[0] >= constants[2]); + computedConstants[104] = (constants[1]*constants[0])^^(constants[2] >= constants[3]); + computedConstants[105] = (constants[1]/constants[0])^^(constants[2] >= constants[3]); + computedConstants[106] = (constants[1] <= constants[0])^^(constants[2]+constants[3]); + computedConstants[107] = (constants[1] <= constants[0])^^constants[2]; + computedConstants[108] = (constants[1] <= constants[0])^^constants[2]-constants[3]; + computedConstants[109] = (constants[1] <= constants[0])^^-constants[2]; + computedConstants[110] = (constants[1] <= constants[0])^^(constants[2]*constants[3]); + computedConstants[111] = (constants[1] <= constants[0])^^(constants[2]/constants[3]); + computedConstants[112] = (constants[1] <= constants[0])^^(constants[2]^^constants[3]); + computedConstants[113] = (constants[1] <= constants[0])^^(constants[2]^^(1.0/constants[3])); + computedConstants[114] = sqrt(constants[1]); + computedConstants[115] = sqrt(constants[1]); + computedConstants[116] = constants[1]^^(1.0/3.0); + computedConstants[117] = constants[1]^^(1.0/constants[0]); + computedConstants[118] = (constants[1] < constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[119] = (constants[1]+constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[120] = constants[1]^^(1.0/(constants[2] > constants[0])); + computedConstants[121] = (constants[1]-constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[122] = (-constants[1])^^(1.0/(constants[2] > constants[0])); + computedConstants[123] = (constants[1]*constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[124] = (constants[1]/constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[125] = (constants[1] < constants[0])^^(1.0/(constants[2]+constants[3])); + computedConstants[126] = (constants[1] < constants[0])^^(1.0/constants[2]); + computedConstants[127] = (constants[1] < constants[0])^^(1.0/(constants[2]-constants[3])); + computedConstants[128] = (constants[1] < constants[0])^^(1.0/(-constants[2])); + computedConstants[129] = (constants[1] < constants[0])^^(1.0/(constants[2]*constants[3])); + computedConstants[130] = (constants[1] < constants[0])^^(1.0/(constants[2]/constants[3])); + computedConstants[131] = (constants[1] < constants[0])^^(1.0/(constants[2]^^constants[3])); + computedConstants[132] = (constants[1] < constants[0])^^(1.0/(constants[2]^^(1.0/constants[3]))); + computedConstants[133] = fabs(constants[1]); + computedConstants[134] = exp(constants[1]); + computedConstants[135] = log(constants[1]); + computedConstants[136] = log10(constants[1]); + computedConstants[137] = log(constants[1])/log(2.0); + computedConstants[138] = log10(constants[1]); + computedConstants[139] = log(constants[1])/log(constants[0]); + computedConstants[140] = ceil(constants[1]); + computedConstants[141] = floor(constants[1]); + computedConstants[142] = min(constants[1], constants[0]); + computedConstants[143] = min(constants[1], min(constants[0], constants[2])); + computedConstants[144] = max(constants[1], constants[0]); + computedConstants[145] = max(constants[1], max(constants[0], constants[2])); + computedConstants[146] = fmod(constants[1], constants[0]); + computedConstants[147] = sin(constants[1]); + computedConstants[148] = cos(constants[1]); + computedConstants[149] = tan(constants[1]); + computedConstants[150] = sec(constants[1]); + computedConstants[151] = csc(constants[1]); + computedConstants[152] = cot(constants[1]); + computedConstants[153] = sinh(constants[1]); + computedConstants[154] = cosh(constants[1]); + computedConstants[155] = tanh(constants[1]); + computedConstants[156] = sech(constants[1]); + computedConstants[157] = csch(constants[1]); + computedConstants[158] = coth(constants[1]); + computedConstants[159] = asin(constants[1]); + computedConstants[160] = acos(constants[1]); + computedConstants[161] = atan(constants[1]); + computedConstants[162] = asec(constants[1]); + computedConstants[163] = acsc(constants[1]); + computedConstants[164] = acot(constants[1]); + computedConstants[165] = asinh(constants[1]); + computedConstants[166] = acosh(constants[1]); + computedConstants[167] = atanh(constants[1]/2.0); + computedConstants[168] = asech(constants[1]); + computedConstants[169] = acsch(constants[1]); + computedConstants[170] = acoth(2.0*constants[1]); + computedConstants[171] = piecewise(constants[1] > constants[0], constants[1], NAN); + computedConstants[172] = piecewise(constants[1] > constants[0], constants[1], constants[2]); + computedConstants[173] = piecewise(constants[1] > constants[0], constants[1], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], NAN))); + computedConstants[174] = piecewise(constants[1] > constants[0], constants[1], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], constants[6]))); + computedConstants[175] = 123.0+piecewise(constants[1] > constants[0], constants[1], NAN); + computedConstants[180] = constants[1]; + computedConstants[187] = (constants[1] && constants[0])+piecewise(constants[2] > constants[3], constants[0], NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[188] = (constants[1] && constants[0])-(piecewise(constants[2] > constants[3], constants[0], NAN)-(constants[4]-piecewise(constants[2] > constants[3], constants[0], NAN)))-(constants[5] && constants[6]); + computedConstants[189] = (constants[1] && constants[0])*piecewise(constants[2] > constants[3], constants[0], NAN)*constants[4]*piecewise(constants[2] > constants[3], constants[0], NAN)*(constants[5] && constants[6]); + computedConstants[190] = (constants[1] && constants[0])/(piecewise(constants[2] > constants[3], constants[0], NAN)/(constants[4]/piecewise(constants[2] > constants[3], constants[0], NAN))); + computedConstants[191] = (constants[1] || constants[0]) && (constants[1]^constants[0]) && piecewise(constants[2] > constants[3], constants[0], NAN) && constants[4] && piecewise(constants[2] > constants[3], constants[0], NAN) && (constants[1]^constants[0]) && (constants[1] || constants[0]); + computedConstants[192] = (constants[1] && constants[0]) || (constants[1]^constants[0]) || piecewise(constants[2] > constants[3], constants[0], NAN) || constants[4] || piecewise(constants[2] > constants[3], constants[0], NAN) || (constants[1]^constants[0]) || (constants[1] && constants[0]); + computedConstants[193] = (constants[1] && constants[0])^(constants[1] || constants[0])^piecewise(constants[2] > constants[3], constants[0], NAN)^constants[4]^piecewise(constants[2] > constants[3], constants[0], NAN)^(constants[1] || constants[0])^(constants[1] && constants[0]); + computedConstants[194] = (constants[1] && constants[0])^^(piecewise(constants[2] > constants[3], constants[0], NAN)^^(constants[4]^^piecewise(constants[2] > constants[3], constants[0], NAN)^^(constants[1] && constants[0]))); + computedConstants[195] = (constants[1] && constants[0])^^(1.0/(piecewise(constants[2] > constants[3], constants[0], NAN)^^(1.0/constants[4])))^^(1.0/piecewise(constants[2] > constants[3], constants[0], NAN))^^(1.0/(constants[1] && constants[0])); + computedConstants[196] = -(constants[1] && constants[0])-piecewise(constants[2] > constants[3], constants[0], NAN); + computedConstants[197] = computedConstants[199]+computedConstants[198]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + rates[0] = 1.0; +} diff --git a/tests/resources/coverage/generator/model_linux.py b/tests/resources/coverage/generator/model_linux.py new file mode 100644 index 0000000000..e6f1590222 --- /dev/null +++ b/tests/resources/coverage/generator/model_linux.py @@ -0,0 +1,620 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 1 +CONSTANT_COUNT = 7 +COMPUTED_CONSTANT_COUNT = 200 +ALGEBRAIC_VARIABLE_COUNT = 2 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} + +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ + {"name": "n", "units": "dimensionless", "component": "my_component"}, + {"name": "m", "units": "dimensionless", "component": "my_component"}, + {"name": "o", "units": "dimensionless", "component": "my_component"}, + {"name": "p", "units": "dimensionless", "component": "my_component"}, + {"name": "q", "units": "dimensionless", "component": "my_component"}, + {"name": "r", "units": "dimensionless", "component": "my_component"}, + {"name": "s", "units": "dimensionless", "component": "my_component"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "eqnEq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnEqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLtCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGtCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAnd", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOr", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXor", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesDirectUnaryMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesIndirectUnaryMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusUnaryParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerSqrt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerSqr", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerCube", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootSqrt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootSqrtOther", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootCube", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAbs", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnExp", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLn", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog10", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLogCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCeiling", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnFloor", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMax", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMaxMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRem", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCos", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTan", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSec", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCsc", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSinh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCosh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTanh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSech", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCsch", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoth", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccos", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArctan", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsec", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccsc", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsinh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccosh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArctanh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsech", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccsch", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccoth", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiece", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePieceOtherwise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiecePiecePiece", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiecePiecePieceOtherwise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnWithPiecewise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnInteger", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnDouble", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnIntegerWithExponent", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnDoubleWithExponent", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTrue", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnFalse", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnExponentiale", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnInfinity", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNotanumber", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForPlusOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForMinusOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForTimesOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForDivideOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForAndOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForOrOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForXorOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForPowerOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant3", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "eqnPlus", "units": "dimensionless", "component": "my_component"} +] + + +def eq_func(x, y): + return 1.0 if x == y else 0.0 + + +def neq_func(x, y): + return 1.0 if x != y else 0.0 + + +def lt_func(x, y): + return 1.0 if x < y else 0.0 + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def gt_func(x, y): + return 1.0 if x > y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def or_func(x, y): + return 1.0 if bool(x) | bool(y) else 0.0 + + +def xor_func(x, y): + return 1.0 if bool(x) ^ bool(y) else 0.0 + + +def not_func(x): + return 1.0 if not bool(x) else 0.0 + + +def min(x, y): + return x if x < y else y + + +def max(x, y): + return x if x > y else y + + +def sec(x): + return 1.0/cos(x) + + +def csc(x): + return 1.0/sin(x) + + +def cot(x): + return 1.0/tan(x) + + +def sech(x): + return 1.0/cosh(x) + + +def csch(x): + return 1.0/sinh(x) + + +def coth(x): + return 1.0/tanh(x) + + +def asec(x): + return acos(1.0/x) + + +def acsc(x): + return asin(1.0/x) + + +def acot(x): + return atan(1.0/x) + + +def asech(x): + one_over_x = 1.0/x + + return log(one_over_x+sqrt(one_over_x*one_over_x-1.0)) + + +def acsch(x): + one_over_x = 1.0/x + + return log(one_over_x+sqrt(one_over_x*one_over_x+1.0)) + + +def acoth(x): + one_over_x = 1.0/x + + return 0.5*log((1.0+one_over_x)/(1.0-one_over_x)) + + +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 create_external_variables_array(): + return [nan]*EXTERNAL_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] + external_variables = data[6] + + algebraic_variables[0] = u[0] + algebraic_variables[1] = u[1] + + f[0] = sin(algebraic_variables[1])+sin(algebraic_variables[0])+states[0]+computed_constants[197]+constants[1]-1.0 + f[1] = -sin(algebraic_variables[0])+sin(algebraic_variables[1])-computed_constants[199]-computed_constants[197]-computed_constants[198]-0.5 + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): + u = [nan]*2 + + u[0] = algebraic_variables[0] + u[1] = algebraic_variables[1] + + u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) + + algebraic_variables[0] = u[0] + algebraic_variables[1] = u[1] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + constants[0] = 1.23 + constants[1] = 123.0 + constants[2] = 1.0e1 + constants[3] = 1.23e1 + constants[4] = 1.0E1 + constants[5] = 1.23E1 + constants[6] = 7.0 + computed_constants[176] = 123.0 + computed_constants[177] = 123.456789 + computed_constants[178] = 123.0e99 + computed_constants[179] = 123.456789e99 + computed_constants[181] = 1.0 + computed_constants[182] = 0.0 + computed_constants[183] = 2.71828182845905 + computed_constants[184] = 3.14159265358979 + computed_constants[185] = inf + computed_constants[186] = nan + computed_constants[199] = 1.0 + computed_constants[198] = 3.0 + algebraic_variables[0] = 0.0 + algebraic_variables[1] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = eq_func(constants[1], constants[0]) + computed_constants[1] = constants[1]/eq_func(constants[0], constants[0]) + computed_constants[2] = neq_func(constants[1], constants[0]) + computed_constants[3] = constants[1]/neq_func(constants[0], constants[2]) + computed_constants[4] = lt_func(constants[1], constants[0]) + computed_constants[5] = constants[1]/lt_func(constants[0], constants[2]) + computed_constants[6] = leq_func(constants[1], constants[0]) + computed_constants[7] = constants[1]/leq_func(constants[0], constants[2]) + computed_constants[8] = gt_func(constants[1], constants[0]) + computed_constants[9] = constants[1]/gt_func(constants[0], constants[2]) + computed_constants[10] = geq_func(constants[1], constants[0]) + computed_constants[11] = constants[1]/geq_func(constants[0], constants[2]) + computed_constants[12] = and_func(constants[1], constants[0]) + computed_constants[13] = and_func(constants[1], and_func(constants[0], constants[2])) + computed_constants[14] = and_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[15] = and_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[16] = and_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[17] = and_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[18] = and_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[19] = and_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[20] = and_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[21] = and_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[22] = and_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[23] = and_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[24] = and_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[25] = and_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[26] = and_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[27] = constants[1]/and_func(constants[0], constants[2]) + computed_constants[28] = or_func(constants[1], constants[0]) + computed_constants[29] = or_func(constants[1], or_func(constants[0], constants[2])) + computed_constants[30] = or_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[31] = or_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[32] = or_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[33] = or_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[34] = or_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[35] = or_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[36] = or_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[37] = or_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[38] = or_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[39] = or_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[40] = or_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[41] = or_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[42] = or_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[43] = constants[1]/or_func(constants[0], constants[2]) + computed_constants[44] = xor_func(constants[1], constants[0]) + computed_constants[45] = xor_func(constants[1], xor_func(constants[0], constants[2])) + computed_constants[46] = xor_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[47] = xor_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[48] = xor_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[49] = xor_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[50] = xor_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[51] = xor_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[52] = xor_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[53] = xor_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[54] = xor_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[55] = xor_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[56] = xor_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[57] = xor_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[58] = xor_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[59] = constants[1]/xor_func(constants[0], constants[2]) + computed_constants[60] = not_func(constants[1]) + computed_constants[61] = constants[1]+constants[0]+constants[2] + computed_constants[62] = lt_func(constants[1], constants[0])+gt_func(constants[2], constants[3]) + computed_constants[63] = constants[1] + computed_constants[64] = constants[1]-constants[0] + computed_constants[65] = lt_func(constants[1], constants[0])-gt_func(constants[2], constants[3]) + computed_constants[66] = lt_func(constants[1], constants[0])-(constants[2]+constants[3]) + computed_constants[67] = lt_func(constants[1], constants[0])-constants[2] + computed_constants[68] = constants[1]-(-constants[0]) + computed_constants[69] = constants[1]-(-constants[0]*constants[2]) + computed_constants[70] = -constants[1] + computed_constants[71] = -lt_func(constants[1], constants[0]) + computed_constants[72] = constants[1]*constants[0] + computed_constants[73] = constants[1]*constants[0]*constants[2] + computed_constants[74] = lt_func(constants[1], constants[0])*gt_func(constants[2], constants[3]) + computed_constants[75] = (constants[1]+constants[0])*gt_func(constants[2], constants[3]) + computed_constants[76] = constants[1]*gt_func(constants[0], constants[2]) + computed_constants[77] = (constants[1]-constants[0])*gt_func(constants[2], constants[3]) + computed_constants[78] = -constants[1]*gt_func(constants[0], constants[2]) + computed_constants[79] = lt_func(constants[1], constants[0])*(constants[2]+constants[3]) + computed_constants[80] = lt_func(constants[1], constants[0])*constants[2] + computed_constants[81] = lt_func(constants[1], constants[0])*(constants[2]-constants[3]) + computed_constants[82] = lt_func(constants[1], constants[0])*-constants[2] + computed_constants[83] = constants[1]/constants[0] + computed_constants[84] = lt_func(constants[1], constants[0])/gt_func(constants[3], constants[2]) + computed_constants[85] = (constants[1]+constants[0])/gt_func(constants[3], constants[2]) + computed_constants[86] = constants[1]/gt_func(constants[2], constants[0]) + computed_constants[87] = (constants[1]-constants[0])/gt_func(constants[3], constants[2]) + computed_constants[88] = -constants[1]/gt_func(constants[2], constants[0]) + computed_constants[89] = lt_func(constants[1], constants[0])/(constants[2]+constants[3]) + computed_constants[90] = lt_func(constants[1], constants[0])/constants[2] + computed_constants[91] = lt_func(constants[1], constants[0])/(constants[2]-constants[3]) + computed_constants[92] = lt_func(constants[1], constants[0])/-constants[2] + computed_constants[93] = lt_func(constants[1], constants[0])/(constants[2]*constants[3]) + computed_constants[94] = lt_func(constants[1], constants[0])/(constants[2]/constants[3]) + computed_constants[95] = sqrt(constants[1]) + computed_constants[96] = pow(constants[1], 2.0) + computed_constants[97] = pow(constants[1], 3.0) + computed_constants[98] = pow(constants[1], constants[0]) + computed_constants[99] = pow(leq_func(constants[1], constants[0]), geq_func(constants[2], constants[3])) + computed_constants[100] = pow(constants[1]+constants[0], geq_func(constants[2], constants[3])) + computed_constants[101] = pow(constants[1], geq_func(constants[0], constants[2])) + computed_constants[102] = pow(constants[1]-constants[0], geq_func(constants[2], constants[3])) + computed_constants[103] = pow(-constants[1], geq_func(constants[0], constants[2])) + computed_constants[104] = pow(constants[1]*constants[0], geq_func(constants[2], constants[3])) + computed_constants[105] = pow(constants[1]/constants[0], geq_func(constants[2], constants[3])) + computed_constants[106] = pow(leq_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[107] = pow(leq_func(constants[1], constants[0]), constants[2]) + computed_constants[108] = pow(leq_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[109] = pow(leq_func(constants[1], constants[0]), -constants[2]) + computed_constants[110] = pow(leq_func(constants[1], constants[0]), constants[2]*constants[3]) + computed_constants[111] = pow(leq_func(constants[1], constants[0]), constants[2]/constants[3]) + computed_constants[112] = pow(leq_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[113] = pow(leq_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[114] = sqrt(constants[1]) + computed_constants[115] = sqrt(constants[1]) + computed_constants[116] = pow(constants[1], 1.0/3.0) + computed_constants[117] = pow(constants[1], 1.0/constants[0]) + computed_constants[118] = pow(lt_func(constants[1], constants[0]), 1.0/gt_func(constants[3], constants[2])) + computed_constants[119] = pow(constants[1]+constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[120] = pow(constants[1], 1.0/gt_func(constants[2], constants[0])) + computed_constants[121] = pow(constants[1]-constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[122] = pow(-constants[1], 1.0/gt_func(constants[2], constants[0])) + computed_constants[123] = pow(constants[1]*constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[124] = pow(constants[1]/constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[125] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]+constants[3])) + computed_constants[126] = pow(lt_func(constants[1], constants[0]), 1.0/constants[2]) + computed_constants[127] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]-constants[3])) + computed_constants[128] = pow(lt_func(constants[1], constants[0]), 1.0/-constants[2]) + computed_constants[129] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]*constants[3])) + computed_constants[130] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]/constants[3])) + computed_constants[131] = pow(lt_func(constants[1], constants[0]), 1.0/pow(constants[2], constants[3])) + computed_constants[132] = pow(lt_func(constants[1], constants[0]), 1.0/pow(constants[2], 1.0/constants[3])) + computed_constants[133] = fabs(constants[1]) + computed_constants[134] = exp(constants[1]) + computed_constants[135] = log(constants[1]) + computed_constants[136] = log10(constants[1]) + computed_constants[137] = log(constants[1])/log(2.0) + computed_constants[138] = log10(constants[1]) + computed_constants[139] = log(constants[1])/log(constants[0]) + computed_constants[140] = ceil(constants[1]) + computed_constants[141] = floor(constants[1]) + computed_constants[142] = min(constants[1], constants[0]) + computed_constants[143] = min(constants[1], min(constants[0], constants[2])) + computed_constants[144] = max(constants[1], constants[0]) + computed_constants[145] = max(constants[1], max(constants[0], constants[2])) + computed_constants[146] = fmod(constants[1], constants[0]) + computed_constants[147] = sin(constants[1]) + computed_constants[148] = cos(constants[1]) + computed_constants[149] = tan(constants[1]) + computed_constants[150] = sec(constants[1]) + computed_constants[151] = csc(constants[1]) + computed_constants[152] = cot(constants[1]) + computed_constants[153] = sinh(constants[1]) + computed_constants[154] = cosh(constants[1]) + computed_constants[155] = tanh(constants[1]) + computed_constants[156] = sech(constants[1]) + computed_constants[157] = csch(constants[1]) + computed_constants[158] = coth(constants[1]) + computed_constants[159] = asin(constants[1]) + computed_constants[160] = acos(constants[1]) + computed_constants[161] = atan(constants[1]) + computed_constants[162] = asec(constants[1]) + computed_constants[163] = acsc(constants[1]) + computed_constants[164] = acot(constants[1]) + computed_constants[165] = asinh(constants[1]) + computed_constants[166] = acosh(constants[1]) + computed_constants[167] = atanh(constants[1]/2.0) + computed_constants[168] = asech(constants[1]) + computed_constants[169] = acsch(constants[1]) + computed_constants[170] = acoth(2.0*constants[1]) + computed_constants[171] = constants[1] if gt_func(constants[1], constants[0]) else nan + computed_constants[172] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] + computed_constants[173] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan + computed_constants[174] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] + computed_constants[175] = 123.0+(constants[1] if gt_func(constants[1], constants[0]) else nan) + computed_constants[180] = constants[1] + computed_constants[187] = and_func(constants[1], constants[0])+(constants[0] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) + computed_constants[188] = and_func(constants[1], constants[0])-((constants[0] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[0] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) + computed_constants[189] = and_func(constants[1], constants[0])*(constants[0] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[0] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) + computed_constants[190] = and_func(constants[1], constants[0])/((constants[0] if gt_func(constants[2], constants[3]) else nan)/(constants[4]/(constants[0] if gt_func(constants[2], constants[3]) else nan))) + computed_constants[191] = and_func(or_func(constants[1], constants[0]), and_func(xor_func(constants[1], constants[0]), and_func(constants[0] if gt_func(constants[2], constants[3]) else nan, and_func(and_func(and_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[1], constants[0])), or_func(constants[1], constants[0]))))) + computed_constants[192] = or_func(and_func(constants[1], constants[0]), or_func(xor_func(constants[1], constants[0]), or_func(constants[0] if gt_func(constants[2], constants[3]) else nan, or_func(or_func(or_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[1], constants[0])), and_func(constants[1], constants[0]))))) + computed_constants[193] = xor_func(and_func(constants[1], constants[0]), xor_func(or_func(constants[1], constants[0]), xor_func(constants[0] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), or_func(constants[1], constants[0])), and_func(constants[1], constants[0]))))) + computed_constants[194] = pow(and_func(constants[1], constants[0]), pow(constants[0] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), and_func(constants[1], constants[0])))) + computed_constants[195] = pow(pow(pow(and_func(constants[1], constants[0]), 1.0/pow(constants[0] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[0] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[1], constants[0])) + computed_constants[196] = -and_func(constants[1], constants[0])-(constants[0] if gt_func(constants[2], constants[3]) else nan) + computed_constants[197] = computed_constants[199]+computed_constants[198] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + rates[0] = 1.0 + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) diff --git a/tests/resources/coverage/generator/model_macos.c b/tests/resources/coverage/generator/model_macos.c new file mode 100644 index 0000000000..29bc2302d7 --- /dev/null +++ b/tests/resources/coverage/generator/model_macos.c @@ -0,0 +1,657 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 1; +const size_t CONSTANT_COUNT = 7; +const size_t COMPUTED_CONSTANT_COUNT = 200; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"t", "second", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"n", "dimensionless", "my_component"}, + {"m", "dimensionless", "my_component"}, + {"o", "dimensionless", "my_component"}, + {"p", "dimensionless", "my_component"}, + {"q", "dimensionless", "my_component"}, + {"r", "dimensionless", "my_component"}, + {"s", "dimensionless", "my_component"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"eqnEq", "dimensionless", "my_component"}, + {"eqnEqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnNeq", "dimensionless", "my_component"}, + {"eqnNeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnLt", "dimensionless", "my_component"}, + {"eqnLtCoverageParentheses", "dimensionless", "my_component"}, + {"eqnLeq", "dimensionless", "my_component"}, + {"eqnLeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnGt", "dimensionless", "my_component"}, + {"eqnGtCoverageParentheses", "dimensionless", "my_component"}, + {"eqnGeq", "dimensionless", "my_component"}, + {"eqnGeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnAnd", "dimensionless", "my_component"}, + {"eqnAndMultiple", "dimensionless", "my_component"}, + {"eqnAndParentheses", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnAndCoverageParentheses", "dimensionless", "my_component"}, + {"eqnOr", "dimensionless", "my_component"}, + {"eqnOrMultiple", "dimensionless", "my_component"}, + {"eqnOrParentheses", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnOrCoverageParentheses", "dimensionless", "my_component"}, + {"eqnXor", "dimensionless", "my_component"}, + {"eqnXorMultiple", "dimensionless", "my_component"}, + {"eqnXorParentheses", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnXorCoverageParentheses", "dimensionless", "my_component"}, + {"eqnNot", "dimensionless", "my_component"}, + {"eqnPlusMultiple", "dimensionless", "my_component"}, + {"eqnPlusParentheses", "dimensionless", "my_component"}, + {"eqnPlusUnary", "dimensionless", "my_component"}, + {"eqnMinus", "dimensionless", "my_component"}, + {"eqnMinusParentheses", "dimensionless", "my_component"}, + {"eqnMinusParenthesesPlusWith", "dimensionless", "my_component"}, + {"eqnMinusParenthesesPlusWithout", "dimensionless", "my_component"}, + {"eqnMinusParenthesesDirectUnaryMinus", "dimensionless", "my_component"}, + {"eqnMinusParenthesesIndirectUnaryMinus", "dimensionless", "my_component"}, + {"eqnMinusUnary", "dimensionless", "my_component"}, + {"eqnMinusUnaryParentheses", "dimensionless", "my_component"}, + {"eqnTimes", "dimensionless", "my_component"}, + {"eqnTimesMultiple", "dimensionless", "my_component"}, + {"eqnTimesParentheses", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnDivide", "dimensionless", "my_component"}, + {"eqnDivideParentheses", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnPowerSqrt", "dimensionless", "my_component"}, + {"eqnPowerSqr", "dimensionless", "my_component"}, + {"eqnPowerCube", "dimensionless", "my_component"}, + {"eqnPowerCi", "dimensionless", "my_component"}, + {"eqnPowerParentheses", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftTimes", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftDivide", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnRootSqrt", "dimensionless", "my_component"}, + {"eqnRootSqrtOther", "dimensionless", "my_component"}, + {"eqnRootCube", "dimensionless", "my_component"}, + {"eqnRootCi", "dimensionless", "my_component"}, + {"eqnRootParentheses", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftTimes", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftDivide", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnAbs", "dimensionless", "my_component"}, + {"eqnExp", "dimensionless", "my_component"}, + {"eqnLn", "dimensionless", "my_component"}, + {"eqnLog", "dimensionless", "my_component"}, + {"eqnLog2", "dimensionless", "my_component"}, + {"eqnLog10", "dimensionless", "my_component"}, + {"eqnLogCi", "dimensionless", "my_component"}, + {"eqnCeiling", "dimensionless", "my_component"}, + {"eqnFloor", "dimensionless", "my_component"}, + {"eqnMin", "dimensionless", "my_component"}, + {"eqnMinMultiple", "dimensionless", "my_component"}, + {"eqnMax", "dimensionless", "my_component"}, + {"eqnMaxMultiple", "dimensionless", "my_component"}, + {"eqnRem", "dimensionless", "my_component"}, + {"eqnSin", "dimensionless", "my_component"}, + {"eqnCos", "dimensionless", "my_component"}, + {"eqnTan", "dimensionless", "my_component"}, + {"eqnSec", "dimensionless", "my_component"}, + {"eqnCsc", "dimensionless", "my_component"}, + {"eqnCot", "dimensionless", "my_component"}, + {"eqnSinh", "dimensionless", "my_component"}, + {"eqnCosh", "dimensionless", "my_component"}, + {"eqnTanh", "dimensionless", "my_component"}, + {"eqnSech", "dimensionless", "my_component"}, + {"eqnCsch", "dimensionless", "my_component"}, + {"eqnCoth", "dimensionless", "my_component"}, + {"eqnArcsin", "dimensionless", "my_component"}, + {"eqnArccos", "dimensionless", "my_component"}, + {"eqnArctan", "dimensionless", "my_component"}, + {"eqnArcsec", "dimensionless", "my_component"}, + {"eqnArccsc", "dimensionless", "my_component"}, + {"eqnArccot", "dimensionless", "my_component"}, + {"eqnArcsinh", "dimensionless", "my_component"}, + {"eqnArccosh", "dimensionless", "my_component"}, + {"eqnArctanh", "dimensionless", "my_component"}, + {"eqnArcsech", "dimensionless", "my_component"}, + {"eqnArccsch", "dimensionless", "my_component"}, + {"eqnArccoth", "dimensionless", "my_component"}, + {"eqnPiecewisePiece", "dimensionless", "my_component"}, + {"eqnPiecewisePieceOtherwise", "dimensionless", "my_component"}, + {"eqnPiecewisePiecePiecePiece", "dimensionless", "my_component"}, + {"eqnPiecewisePiecePiecePieceOtherwise", "dimensionless", "my_component"}, + {"eqnWithPiecewise", "dimensionless", "my_component"}, + {"eqnCnInteger", "dimensionless", "my_component"}, + {"eqnCnDouble", "dimensionless", "my_component"}, + {"eqnCnIntegerWithExponent", "dimensionless", "my_component"}, + {"eqnCnDoubleWithExponent", "dimensionless", "my_component"}, + {"eqnCi", "dimensionless", "my_component"}, + {"eqnTrue", "dimensionless", "my_component"}, + {"eqnFalse", "dimensionless", "my_component"}, + {"eqnExponentiale", "dimensionless", "my_component"}, + {"eqnPi", "dimensionless", "my_component"}, + {"eqnInfinity", "dimensionless", "my_component"}, + {"eqnNotanumber", "dimensionless", "my_component"}, + {"eqnCoverageForPlusOperator", "dimensionless", "my_component"}, + {"eqnCoverageForMinusOperator", "dimensionless", "my_component"}, + {"eqnCoverageForTimesOperator", "dimensionless", "my_component"}, + {"eqnCoverageForDivideOperator", "dimensionless", "my_component"}, + {"eqnCoverageForAndOperator", "dimensionless", "my_component"}, + {"eqnCoverageForOrOperator", "dimensionless", "my_component"}, + {"eqnCoverageForXorOperator", "dimensionless", "my_component"}, + {"eqnCoverageForPowerOperator", "dimensionless", "my_component"}, + {"eqnCoverageForRootOperator", "dimensionless", "my_component"}, + {"eqnCoverageForMinusUnary", "dimensionless", "my_component"}, + {"eqnComputedConstant3", "dimensionless", "my_component"}, + {"eqnComputedConstant2", "dimensionless", "my_component"}, + {"eqnComputedConstant1", "dimensionless", "my_component"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"eqnNlaVariable2", "dimensionless", "my_component"}, + {"eqnNlaVariable1", "dimensionless", "my_component"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"eqnPlus", "dimensionless", "my_component"} +}; + +double xor(double x, double y) +{ + return (x != 0.0) ^ (y != 0.0); +} + +double min(double x, double y) +{ + return (x < y)?x:y; +} + +double max(double x, double y) +{ + return (x > y)?x:y; +} + +double sec(double x) +{ + return 1.0/cos(x); +} + +double csc(double x) +{ + return 1.0/sin(x); +} + +double cot(double x) +{ + return 1.0/tan(x); +} + +double sech(double x) +{ + return 1.0/cosh(x); +} + +double csch(double x) +{ + return 1.0/sinh(x); +} + +double coth(double x) +{ + return 1.0/tanh(x); +} + +double asec(double x) +{ + return acos(1.0/x); +} + +double acsc(double x) +{ + return asin(1.0/x); +} + +double acot(double x) +{ + return atan(1.0/x); +} + +double asech(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX-1.0)); +} + +double acsch(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX+1.0)); +} + +double acoth(double x) +{ + double oneOverX = 1.0/x; + + return 0.5*log((1.0+oneOverX)/(1.0-oneOverX)); +} + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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; + double *externalVariables; +} 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; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; + + f[0] = sin(algebraicVariables[1])+sin(algebraicVariables[0])+states[0]+computedConstants[197]+constants[1]-1.0; + f[1] = -computedConstants[197]-sin(algebraicVariables[0])-computedConstants[198]-computedConstants[199]+sin(algebraicVariables[1])-0.5; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; + double u[2]; + + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; + + nlaSolve(objectiveFunction0, u, 2, &rfi); + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + constants[0] = 1.23; + constants[1] = 123.0; + constants[2] = 1.0e1; + constants[3] = 1.23e1; + constants[4] = 1.0E1; + constants[5] = 1.23E1; + constants[6] = 7.0; + computedConstants[176] = 123.0; + computedConstants[177] = 123.456789; + computedConstants[178] = 123.0e99; + computedConstants[179] = 123.456789e99; + computedConstants[181] = 1.0; + computedConstants[182] = 0.0; + computedConstants[183] = 2.71828182845905; + computedConstants[184] = 3.14159265358979; + computedConstants[185] = INFINITY; + computedConstants[186] = NAN; + computedConstants[199] = 1.0; + computedConstants[198] = 3.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[1] == constants[0]; + computedConstants[1] = constants[1]/(constants[0] == constants[0]); + computedConstants[2] = constants[1] != constants[0]; + computedConstants[3] = constants[1]/(constants[0] != constants[2]); + computedConstants[4] = constants[1] < constants[0]; + computedConstants[5] = constants[1]/(constants[0] < constants[2]); + computedConstants[6] = constants[1] <= constants[0]; + computedConstants[7] = constants[1]/(constants[0] <= constants[2]); + computedConstants[8] = constants[1] > constants[0]; + computedConstants[9] = constants[1]/(constants[0] > constants[2]); + computedConstants[10] = constants[1] >= constants[0]; + computedConstants[11] = constants[1]/(constants[0] >= constants[2]); + computedConstants[12] = constants[1] && constants[0]; + computedConstants[13] = constants[1] && constants[0] && constants[2]; + computedConstants[14] = (constants[1] < constants[0]) && (constants[2] > constants[3]); + computedConstants[15] = (constants[1]+constants[0]) && (constants[2] > constants[3]); + computedConstants[16] = constants[1] && (constants[0] > constants[2]); + computedConstants[17] = (constants[1]-constants[0]) && (constants[2] > constants[3]); + computedConstants[18] = -constants[1] && (constants[0] > constants[2]); + computedConstants[19] = pow(constants[1], constants[0]) && (constants[2] > constants[3]); + computedConstants[20] = pow(constants[1], 1.0/constants[0]) && (constants[2] > constants[3]); + computedConstants[21] = (constants[1] < constants[0]) && (constants[2]+constants[3]); + computedConstants[22] = (constants[1] < constants[0]) && constants[2]; + computedConstants[23] = (constants[1] < constants[0]) && (constants[2]-constants[3]); + computedConstants[24] = (constants[1] < constants[0]) && -constants[2]; + computedConstants[25] = (constants[1] < constants[0]) && pow(constants[2], constants[3]); + computedConstants[26] = (constants[1] < constants[0]) && pow(constants[2], 1.0/constants[3]); + computedConstants[27] = constants[1]/(constants[0] && constants[2]); + computedConstants[28] = constants[1] || constants[0]; + computedConstants[29] = constants[1] || constants[0] || constants[2]; + computedConstants[30] = (constants[1] < constants[0]) || (constants[2] > constants[3]); + computedConstants[31] = (constants[1]+constants[0]) || (constants[2] > constants[3]); + computedConstants[32] = constants[1] || (constants[0] > constants[2]); + computedConstants[33] = (constants[1]-constants[0]) || (constants[2] > constants[3]); + computedConstants[34] = -constants[1] || (constants[0] > constants[2]); + computedConstants[35] = pow(constants[1], constants[0]) || (constants[2] > constants[3]); + computedConstants[36] = pow(constants[1], 1.0/constants[0]) || (constants[2] > constants[3]); + computedConstants[37] = (constants[1] < constants[0]) || (constants[2]+constants[3]); + computedConstants[38] = (constants[1] < constants[0]) || constants[2]; + computedConstants[39] = (constants[1] < constants[0]) || (constants[2]-constants[3]); + computedConstants[40] = (constants[1] < constants[0]) || -constants[2]; + computedConstants[41] = (constants[1] < constants[0]) || pow(constants[2], constants[3]); + computedConstants[42] = (constants[1] < constants[0]) || pow(constants[2], 1.0/constants[3]); + computedConstants[43] = constants[1]/(constants[0] || constants[2]); + computedConstants[44] = xor(constants[1], constants[0]); + computedConstants[45] = xor(constants[1], xor(constants[0], constants[2])); + computedConstants[46] = xor(constants[1] < constants[0], constants[2] > constants[3]); + computedConstants[47] = xor(constants[1]+constants[0], constants[2] > constants[3]); + computedConstants[48] = xor(constants[1], constants[0] > constants[2]); + computedConstants[49] = xor(constants[1]-constants[0], constants[2] > constants[3]); + computedConstants[50] = xor(-constants[1], constants[0] > constants[2]); + computedConstants[51] = xor(pow(constants[1], constants[0]), constants[2] > constants[3]); + computedConstants[52] = xor(pow(constants[1], 1.0/constants[0]), constants[2] > constants[3]); + computedConstants[53] = xor(constants[1] < constants[0], constants[2]+constants[3]); + computedConstants[54] = xor(constants[1] < constants[0], constants[2]); + computedConstants[55] = xor(constants[1] < constants[0], constants[2]-constants[3]); + computedConstants[56] = xor(constants[1] < constants[0], -constants[2]); + computedConstants[57] = xor(constants[1] < constants[0], pow(constants[2], constants[3])); + computedConstants[58] = xor(constants[1] < constants[0], pow(constants[2], 1.0/constants[3])); + computedConstants[59] = constants[1]/xor(constants[0], constants[2]); + computedConstants[60] = !constants[1]; + computedConstants[61] = constants[1]+constants[0]+constants[2]; + computedConstants[62] = (constants[1] < constants[0])+(constants[2] > constants[3]); + computedConstants[63] = constants[1]; + computedConstants[64] = constants[1]-constants[0]; + computedConstants[65] = (constants[1] < constants[0])-(constants[2] > constants[3]); + computedConstants[66] = (constants[1] < constants[0])-(constants[2]+constants[3]); + computedConstants[67] = (constants[1] < constants[0])-constants[2]; + computedConstants[68] = constants[1]-(-constants[0]); + computedConstants[69] = constants[1]-(-constants[0]*constants[2]); + computedConstants[70] = -constants[1]; + computedConstants[71] = -(constants[1] < constants[0]); + computedConstants[72] = constants[1]*constants[0]; + computedConstants[73] = constants[1]*constants[0]*constants[2]; + computedConstants[74] = (constants[1] < constants[0])*(constants[2] > constants[3]); + computedConstants[75] = (constants[1]+constants[0])*(constants[2] > constants[3]); + computedConstants[76] = constants[1]*(constants[0] > constants[2]); + computedConstants[77] = (constants[1]-constants[0])*(constants[2] > constants[3]); + computedConstants[78] = -constants[1]*(constants[0] > constants[2]); + computedConstants[79] = (constants[1] < constants[0])*(constants[2]+constants[3]); + computedConstants[80] = (constants[1] < constants[0])*constants[2]; + computedConstants[81] = (constants[1] < constants[0])*(constants[2]-constants[3]); + computedConstants[82] = (constants[1] < constants[0])*-constants[2]; + computedConstants[83] = constants[1]/constants[0]; + computedConstants[84] = (constants[1] < constants[0])/(constants[3] > constants[2]); + computedConstants[85] = (constants[1]+constants[0])/(constants[3] > constants[2]); + computedConstants[86] = constants[1]/(constants[2] > constants[0]); + computedConstants[87] = (constants[1]-constants[0])/(constants[3] > constants[2]); + computedConstants[88] = -constants[1]/(constants[2] > constants[0]); + computedConstants[89] = (constants[1] < constants[0])/(constants[2]+constants[3]); + computedConstants[90] = (constants[1] < constants[0])/constants[2]; + computedConstants[91] = (constants[1] < constants[0])/(constants[2]-constants[3]); + computedConstants[92] = (constants[1] < constants[0])/-constants[2]; + computedConstants[93] = (constants[1] < constants[0])/(constants[2]*constants[3]); + computedConstants[94] = (constants[1] < constants[0])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[1]); + computedConstants[96] = pow(constants[1], 2.0); + computedConstants[97] = pow(constants[1], 3.0); + computedConstants[98] = pow(constants[1], constants[0]); + computedConstants[99] = pow(constants[1] <= constants[0], constants[2] >= constants[3]); + computedConstants[100] = pow(constants[1]+constants[0], constants[2] >= constants[3]); + computedConstants[101] = pow(constants[1], constants[0] >= constants[2]); + computedConstants[102] = pow(constants[1]-constants[0], constants[2] >= constants[3]); + computedConstants[103] = pow(-constants[1], constants[0] >= constants[2]); + computedConstants[104] = pow(constants[1]*constants[0], constants[2] >= constants[3]); + computedConstants[105] = pow(constants[1]/constants[0], constants[2] >= constants[3]); + computedConstants[106] = pow(constants[1] <= constants[0], constants[2]+constants[3]); + computedConstants[107] = pow(constants[1] <= constants[0], constants[2]); + computedConstants[108] = pow(constants[1] <= constants[0], constants[2]-constants[3]); + computedConstants[109] = pow(constants[1] <= constants[0], -constants[2]); + computedConstants[110] = pow(constants[1] <= constants[0], constants[2]*constants[3]); + computedConstants[111] = pow(constants[1] <= constants[0], constants[2]/constants[3]); + computedConstants[112] = pow(constants[1] <= constants[0], pow(constants[2], constants[3])); + computedConstants[113] = pow(constants[1] <= constants[0], pow(constants[2], 1.0/constants[3])); + computedConstants[114] = sqrt(constants[1]); + computedConstants[115] = sqrt(constants[1]); + computedConstants[116] = pow(constants[1], 1.0/3.0); + computedConstants[117] = pow(constants[1], 1.0/constants[0]); + computedConstants[118] = pow(constants[1] < constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[119] = pow(constants[1]+constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[120] = pow(constants[1], 1.0/(constants[2] > constants[0])); + computedConstants[121] = pow(constants[1]-constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[122] = pow(-constants[1], 1.0/(constants[2] > constants[0])); + computedConstants[123] = pow(constants[1]*constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[124] = pow(constants[1]/constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[125] = pow(constants[1] < constants[0], 1.0/(constants[2]+constants[3])); + computedConstants[126] = pow(constants[1] < constants[0], 1.0/constants[2]); + computedConstants[127] = pow(constants[1] < constants[0], 1.0/(constants[2]-constants[3])); + computedConstants[128] = pow(constants[1] < constants[0], 1.0/-constants[2]); + computedConstants[129] = pow(constants[1] < constants[0], 1.0/(constants[2]*constants[3])); + computedConstants[130] = pow(constants[1] < constants[0], 1.0/(constants[2]/constants[3])); + computedConstants[131] = pow(constants[1] < constants[0], 1.0/pow(constants[2], constants[3])); + computedConstants[132] = pow(constants[1] < constants[0], 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[133] = fabs(constants[1]); + computedConstants[134] = exp(constants[1]); + computedConstants[135] = log(constants[1]); + computedConstants[136] = log10(constants[1]); + computedConstants[137] = log(constants[1])/log(2.0); + computedConstants[138] = log10(constants[1]); + computedConstants[139] = log(constants[1])/log(constants[0]); + computedConstants[140] = ceil(constants[1]); + computedConstants[141] = floor(constants[1]); + computedConstants[142] = min(constants[1], constants[0]); + computedConstants[143] = min(constants[1], min(constants[0], constants[2])); + computedConstants[144] = max(constants[1], constants[0]); + computedConstants[145] = max(constants[1], max(constants[0], constants[2])); + computedConstants[146] = fmod(constants[1], constants[0]); + computedConstants[147] = sin(constants[1]); + computedConstants[148] = cos(constants[1]); + computedConstants[149] = tan(constants[1]); + computedConstants[150] = sec(constants[1]); + computedConstants[151] = csc(constants[1]); + computedConstants[152] = cot(constants[1]); + computedConstants[153] = sinh(constants[1]); + computedConstants[154] = cosh(constants[1]); + computedConstants[155] = tanh(constants[1]); + computedConstants[156] = sech(constants[1]); + computedConstants[157] = csch(constants[1]); + computedConstants[158] = coth(constants[1]); + computedConstants[159] = asin(constants[1]); + computedConstants[160] = acos(constants[1]); + computedConstants[161] = atan(constants[1]); + computedConstants[162] = asec(constants[1]); + computedConstants[163] = acsc(constants[1]); + computedConstants[164] = acot(constants[1]); + computedConstants[165] = asinh(constants[1]); + computedConstants[166] = acosh(constants[1]); + computedConstants[167] = atanh(constants[1]/2.0); + computedConstants[168] = asech(constants[1]); + computedConstants[169] = acsch(constants[1]); + computedConstants[170] = acoth(2.0*constants[1]); + computedConstants[171] = (constants[1] > constants[0])?constants[1]:NAN; + computedConstants[172] = (constants[1] > constants[0])?constants[1]:constants[2]; + computedConstants[173] = (constants[1] > constants[0])?constants[1]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; + computedConstants[174] = (constants[1] > constants[0])?constants[1]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; + computedConstants[175] = 123.0+((constants[1] > constants[0])?constants[1]:NAN); + computedConstants[180] = constants[1]; + computedConstants[187] = (constants[1] && constants[0])+((constants[2] > constants[3])?constants[0]:NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[188] = (constants[1] && constants[0])-(((constants[2] > constants[3])?constants[0]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[0]:NAN)))-(constants[5] && constants[6]); + computedConstants[189] = (constants[1] && constants[0])*((constants[2] > constants[3])?constants[0]:NAN)*constants[4]*((constants[2] > constants[3])?constants[0]:NAN)*(constants[5] && constants[6]); + computedConstants[190] = (constants[1] && constants[0])/(((constants[2] > constants[3])?constants[0]:NAN)/(constants[4]/((constants[2] > constants[3])?constants[0]:NAN))); + computedConstants[191] = (constants[1] || constants[0]) && xor(constants[1], constants[0]) && ((constants[2] > constants[3])?constants[0]:NAN) && constants[4] && ((constants[2] > constants[3])?constants[0]:NAN) && xor(constants[1], constants[0]) && (constants[1] || constants[0]); + computedConstants[192] = (constants[1] && constants[0]) || xor(constants[1], constants[0]) || ((constants[2] > constants[3])?constants[0]:NAN) || constants[4] || ((constants[2] > constants[3])?constants[0]:NAN) || xor(constants[1], constants[0]) || (constants[1] && constants[0]); + computedConstants[193] = xor(constants[1] && constants[0], xor(constants[1] || constants[0], xor((constants[2] > constants[3])?constants[0]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] || constants[0]), constants[1] && constants[0])))); + computedConstants[194] = pow(constants[1] && constants[0], pow((constants[2] > constants[3])?constants[0]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] && constants[0]))); + computedConstants[195] = pow(pow(pow(constants[1] && constants[0], 1.0/pow((constants[2] > constants[3])?constants[0]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[0]:NAN)), 1.0/(constants[1] && constants[0])); + computedConstants[196] = -(constants[1] && constants[0])-((constants[2] > constants[3])?constants[0]:NAN); + computedConstants[197] = computedConstants[199]+computedConstants[198]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + rates[0] = 1.0; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); +} diff --git a/tests/resources/coverage/generator/model_macos.out b/tests/resources/coverage/generator/model_macos.out new file mode 100644 index 0000000000..bbd8e80275 --- /dev/null +++ b/tests/resources/coverage/generator/model_macos.out @@ -0,0 +1,320 @@ +/* The content of this file was generated using a modified C profile of libCellML 0.7.0. */ + +#include "customheaderfile.h" + +double min(double x, double y) +{ + return (x < y)?x:y; +} + +double max(double x, double y) +{ + return (x > y)?x:y; +} + +double sec(double x) +{ + return 1.0/cos(x); +} + +double csc(double x) +{ + return 1.0/sin(x); +} + +double cot(double x) +{ + return 1.0/tan(x); +} + +double sech(double x) +{ + return 1.0/cosh(x); +} + +double csch(double x) +{ + return 1.0/sinh(x); +} + +double coth(double x) +{ + return 1.0/tanh(x); +} + +double asec(double x) +{ + return acos(1.0/x); +} + +double acsc(double x) +{ + return asin(1.0/x); +} + +double acot(double x) +{ + return atan(1.0/x); +} + +double asech(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX-1.0)); +} + +double acsch(double x) +{ + double oneOverX = 1.0/x; + + return log(oneOverX+sqrt(oneOverX*oneOverX+1.0)); +} + +double acoth(double x) +{ + double oneOverX = 1.0/x; + + return 0.5*log((1.0+oneOverX)/(1.0-oneOverX)); +} + +typedef struct { + double voi; + double *states; + double *rates; + double *constants; + double *computedConstants; + double *algebraicVariables; + double *externalVariables; +} 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; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; + + f[0] = sin(algebraicVariables[1])+sin(algebraicVariables[0])+states[0]+computedConstants[197]+constants[1]-1.0; + f[1] = -computedConstants[197]-sin(algebraicVariables[0])-computedConstants[198]-computedConstants[199]+sin(algebraicVariables[1])-0.5; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; + double u[2]; + + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; + + nlaSolve(objectiveFunction0, u, 2, &rfi); + + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[1] == constants[0]; + computedConstants[1] = constants[1]/(constants[0] == constants[0]); + computedConstants[2] = constants[1] != constants[0]; + computedConstants[3] = constants[1]/(constants[0] != constants[2]); + computedConstants[4] = constants[1] < constants[0]; + computedConstants[5] = constants[1]/(constants[0] < constants[2]); + computedConstants[6] = constants[1] <= constants[0]; + computedConstants[7] = constants[1]/(constants[0] <= constants[2]); + computedConstants[8] = constants[1] > constants[0]; + computedConstants[9] = constants[1]/(constants[0] > constants[2]); + computedConstants[10] = constants[1] >= constants[0]; + computedConstants[11] = constants[1]/(constants[0] >= constants[2]); + computedConstants[12] = constants[1] && constants[0]; + computedConstants[13] = constants[1] && constants[0] && constants[2]; + computedConstants[14] = (constants[1] < constants[0]) && (constants[2] > constants[3]); + computedConstants[15] = (constants[1]+constants[0]) && (constants[2] > constants[3]); + computedConstants[16] = constants[1] && (constants[0] > constants[2]); + computedConstants[17] = (constants[1]-constants[0]) && (constants[2] > constants[3]); + computedConstants[18] = -constants[1] && (constants[0] > constants[2]); + computedConstants[19] = (constants[1]^^constants[0]) && (constants[2] > constants[3]); + computedConstants[20] = (constants[1]^^(1.0/constants[0])) && (constants[2] > constants[3]); + computedConstants[21] = (constants[1] < constants[0]) && (constants[2]+constants[3]); + computedConstants[22] = (constants[1] < constants[0]) && constants[2]; + computedConstants[23] = (constants[1] < constants[0]) && (constants[2]-constants[3]); + computedConstants[24] = (constants[1] < constants[0]) && -constants[2]; + computedConstants[25] = (constants[1] < constants[0]) && (constants[2]^^constants[3]); + computedConstants[26] = (constants[1] < constants[0]) && (constants[2]^^(1.0/constants[3])); + computedConstants[27] = constants[1]/(constants[0] && constants[2]); + computedConstants[28] = constants[1] || constants[0]; + computedConstants[29] = constants[1] || constants[0] || constants[2]; + computedConstants[30] = (constants[1] < constants[0]) || (constants[2] > constants[3]); + computedConstants[31] = (constants[1]+constants[0]) || (constants[2] > constants[3]); + computedConstants[32] = constants[1] || (constants[0] > constants[2]); + computedConstants[33] = (constants[1]-constants[0]) || (constants[2] > constants[3]); + computedConstants[34] = -constants[1] || (constants[0] > constants[2]); + computedConstants[35] = (constants[1]^^constants[0]) || (constants[2] > constants[3]); + computedConstants[36] = (constants[1]^^(1.0/constants[0])) || (constants[2] > constants[3]); + computedConstants[37] = (constants[1] < constants[0]) || (constants[2]+constants[3]); + computedConstants[38] = (constants[1] < constants[0]) || constants[2]; + computedConstants[39] = (constants[1] < constants[0]) || (constants[2]-constants[3]); + computedConstants[40] = (constants[1] < constants[0]) || -constants[2]; + computedConstants[41] = (constants[1] < constants[0]) || (constants[2]^^constants[3]); + computedConstants[42] = (constants[1] < constants[0]) || (constants[2]^^(1.0/constants[3])); + computedConstants[43] = constants[1]/(constants[0] || constants[2]); + computedConstants[44] = constants[1]^constants[0]; + computedConstants[45] = constants[1]^constants[0]^constants[2]; + computedConstants[46] = (constants[1] < constants[0])^(constants[2] > constants[3]); + computedConstants[47] = (constants[1]+constants[0])^(constants[2] > constants[3]); + computedConstants[48] = constants[1]^(constants[0] > constants[2]); + computedConstants[49] = (constants[1]-constants[0])^(constants[2] > constants[3]); + computedConstants[50] = -constants[1]^(constants[0] > constants[2]); + computedConstants[51] = (constants[1]^^constants[0])^(constants[2] > constants[3]); + computedConstants[52] = (constants[1]^^(1.0/constants[0]))^(constants[2] > constants[3]); + computedConstants[53] = (constants[1] < constants[0])^(constants[2]+constants[3]); + computedConstants[54] = (constants[1] < constants[0])^constants[2]; + computedConstants[55] = (constants[1] < constants[0])^(constants[2]-constants[3]); + computedConstants[56] = (constants[1] < constants[0])^-constants[2]; + computedConstants[57] = (constants[1] < constants[0])^(constants[2]^^constants[3]); + computedConstants[58] = (constants[1] < constants[0])^(constants[2]^^(1.0/constants[3])); + computedConstants[59] = constants[1]/(constants[0]^constants[2]); + computedConstants[60] = !constants[1]; + computedConstants[61] = constants[1]+constants[0]+constants[2]; + computedConstants[62] = (constants[1] < constants[0])+(constants[2] > constants[3]); + computedConstants[63] = constants[1]; + computedConstants[64] = constants[1]-constants[0]; + computedConstants[65] = (constants[1] < constants[0])-(constants[2] > constants[3]); + computedConstants[66] = (constants[1] < constants[0])-(constants[2]+constants[3]); + computedConstants[67] = (constants[1] < constants[0])-constants[2]; + computedConstants[68] = constants[1]-(-constants[0]); + computedConstants[69] = constants[1]-(-constants[0]*constants[2]); + computedConstants[70] = -constants[1]; + computedConstants[71] = -(constants[1] < constants[0]); + computedConstants[72] = constants[1]*constants[0]; + computedConstants[73] = constants[1]*constants[0]*constants[2]; + computedConstants[74] = (constants[1] < constants[0])*(constants[2] > constants[3]); + computedConstants[75] = (constants[1]+constants[0])*(constants[2] > constants[3]); + computedConstants[76] = constants[1]*(constants[0] > constants[2]); + computedConstants[77] = (constants[1]-constants[0])*(constants[2] > constants[3]); + computedConstants[78] = -constants[1]*(constants[0] > constants[2]); + computedConstants[79] = (constants[1] < constants[0])*(constants[2]+constants[3]); + computedConstants[80] = (constants[1] < constants[0])*constants[2]; + computedConstants[81] = (constants[1] < constants[0])*(constants[2]-constants[3]); + computedConstants[82] = (constants[1] < constants[0])*-constants[2]; + computedConstants[83] = constants[1]/constants[0]; + computedConstants[84] = (constants[1] < constants[0])/(constants[3] > constants[2]); + computedConstants[85] = (constants[1]+constants[0])/(constants[3] > constants[2]); + computedConstants[86] = constants[1]/(constants[2] > constants[0]); + computedConstants[87] = (constants[1]-constants[0])/(constants[3] > constants[2]); + computedConstants[88] = -constants[1]/(constants[2] > constants[0]); + computedConstants[89] = (constants[1] < constants[0])/(constants[2]+constants[3]); + computedConstants[90] = (constants[1] < constants[0])/constants[2]; + computedConstants[91] = (constants[1] < constants[0])/(constants[2]-constants[3]); + computedConstants[92] = (constants[1] < constants[0])/-constants[2]; + computedConstants[93] = (constants[1] < constants[0])/(constants[2]*constants[3]); + computedConstants[94] = (constants[1] < constants[0])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[1]); + computedConstants[96] = sqr(constants[1]); + computedConstants[97] = constants[1]^^3.0; + computedConstants[98] = constants[1]^^constants[0]; + computedConstants[99] = (constants[1] <= constants[0])^^(constants[2] >= constants[3]); + computedConstants[100] = (constants[1]+constants[0])^^(constants[2] >= constants[3]); + computedConstants[101] = constants[1]^^(constants[0] >= constants[2]); + computedConstants[102] = (constants[1]-constants[0])^^(constants[2] >= constants[3]); + computedConstants[103] = (-constants[1])^^(constants[0] >= constants[2]); + computedConstants[104] = (constants[1]*constants[0])^^(constants[2] >= constants[3]); + computedConstants[105] = (constants[1]/constants[0])^^(constants[2] >= constants[3]); + computedConstants[106] = (constants[1] <= constants[0])^^(constants[2]+constants[3]); + computedConstants[107] = (constants[1] <= constants[0])^^constants[2]; + computedConstants[108] = (constants[1] <= constants[0])^^constants[2]-constants[3]; + computedConstants[109] = (constants[1] <= constants[0])^^-constants[2]; + computedConstants[110] = (constants[1] <= constants[0])^^(constants[2]*constants[3]); + computedConstants[111] = (constants[1] <= constants[0])^^(constants[2]/constants[3]); + computedConstants[112] = (constants[1] <= constants[0])^^(constants[2]^^constants[3]); + computedConstants[113] = (constants[1] <= constants[0])^^(constants[2]^^(1.0/constants[3])); + computedConstants[114] = sqrt(constants[1]); + computedConstants[115] = sqrt(constants[1]); + computedConstants[116] = constants[1]^^(1.0/3.0); + computedConstants[117] = constants[1]^^(1.0/constants[0]); + computedConstants[118] = (constants[1] < constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[119] = (constants[1]+constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[120] = constants[1]^^(1.0/(constants[2] > constants[0])); + computedConstants[121] = (constants[1]-constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[122] = (-constants[1])^^(1.0/(constants[2] > constants[0])); + computedConstants[123] = (constants[1]*constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[124] = (constants[1]/constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[125] = (constants[1] < constants[0])^^(1.0/(constants[2]+constants[3])); + computedConstants[126] = (constants[1] < constants[0])^^(1.0/constants[2]); + computedConstants[127] = (constants[1] < constants[0])^^(1.0/(constants[2]-constants[3])); + computedConstants[128] = (constants[1] < constants[0])^^(1.0/(-constants[2])); + computedConstants[129] = (constants[1] < constants[0])^^(1.0/(constants[2]*constants[3])); + computedConstants[130] = (constants[1] < constants[0])^^(1.0/(constants[2]/constants[3])); + computedConstants[131] = (constants[1] < constants[0])^^(1.0/(constants[2]^^constants[3])); + computedConstants[132] = (constants[1] < constants[0])^^(1.0/(constants[2]^^(1.0/constants[3]))); + computedConstants[133] = fabs(constants[1]); + computedConstants[134] = exp(constants[1]); + computedConstants[135] = log(constants[1]); + computedConstants[136] = log10(constants[1]); + computedConstants[137] = log(constants[1])/log(2.0); + computedConstants[138] = log10(constants[1]); + computedConstants[139] = log(constants[1])/log(constants[0]); + computedConstants[140] = ceil(constants[1]); + computedConstants[141] = floor(constants[1]); + computedConstants[142] = min(constants[1], constants[0]); + computedConstants[143] = min(constants[1], min(constants[0], constants[2])); + computedConstants[144] = max(constants[1], constants[0]); + computedConstants[145] = max(constants[1], max(constants[0], constants[2])); + computedConstants[146] = fmod(constants[1], constants[0]); + computedConstants[147] = sin(constants[1]); + computedConstants[148] = cos(constants[1]); + computedConstants[149] = tan(constants[1]); + computedConstants[150] = sec(constants[1]); + computedConstants[151] = csc(constants[1]); + computedConstants[152] = cot(constants[1]); + computedConstants[153] = sinh(constants[1]); + computedConstants[154] = cosh(constants[1]); + computedConstants[155] = tanh(constants[1]); + computedConstants[156] = sech(constants[1]); + computedConstants[157] = csch(constants[1]); + computedConstants[158] = coth(constants[1]); + computedConstants[159] = asin(constants[1]); + computedConstants[160] = acos(constants[1]); + computedConstants[161] = atan(constants[1]); + computedConstants[162] = asec(constants[1]); + computedConstants[163] = acsc(constants[1]); + computedConstants[164] = acot(constants[1]); + computedConstants[165] = asinh(constants[1]); + computedConstants[166] = acosh(constants[1]); + computedConstants[167] = atanh(constants[1]/2.0); + computedConstants[168] = asech(constants[1]); + computedConstants[169] = acsch(constants[1]); + computedConstants[170] = acoth(2.0*constants[1]); + computedConstants[171] = piecewise(constants[1] > constants[0], constants[1], NAN); + computedConstants[172] = piecewise(constants[1] > constants[0], constants[1], constants[2]); + computedConstants[173] = piecewise(constants[1] > constants[0], constants[1], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], NAN))); + computedConstants[174] = piecewise(constants[1] > constants[0], constants[1], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], constants[6]))); + computedConstants[175] = 123.0+piecewise(constants[1] > constants[0], constants[1], NAN); + computedConstants[180] = constants[1]; + computedConstants[187] = (constants[1] && constants[0])+piecewise(constants[2] > constants[3], constants[0], NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[188] = (constants[1] && constants[0])-(piecewise(constants[2] > constants[3], constants[0], NAN)-(constants[4]-piecewise(constants[2] > constants[3], constants[0], NAN)))-(constants[5] && constants[6]); + computedConstants[189] = (constants[1] && constants[0])*piecewise(constants[2] > constants[3], constants[0], NAN)*constants[4]*piecewise(constants[2] > constants[3], constants[0], NAN)*(constants[5] && constants[6]); + computedConstants[190] = (constants[1] && constants[0])/(piecewise(constants[2] > constants[3], constants[0], NAN)/(constants[4]/piecewise(constants[2] > constants[3], constants[0], NAN))); + computedConstants[191] = (constants[1] || constants[0]) && (constants[1]^constants[0]) && piecewise(constants[2] > constants[3], constants[0], NAN) && constants[4] && piecewise(constants[2] > constants[3], constants[0], NAN) && (constants[1]^constants[0]) && (constants[1] || constants[0]); + computedConstants[192] = (constants[1] && constants[0]) || (constants[1]^constants[0]) || piecewise(constants[2] > constants[3], constants[0], NAN) || constants[4] || piecewise(constants[2] > constants[3], constants[0], NAN) || (constants[1]^constants[0]) || (constants[1] && constants[0]); + computedConstants[193] = (constants[1] && constants[0])^(constants[1] || constants[0])^piecewise(constants[2] > constants[3], constants[0], NAN)^constants[4]^piecewise(constants[2] > constants[3], constants[0], NAN)^(constants[1] || constants[0])^(constants[1] && constants[0]); + computedConstants[194] = (constants[1] && constants[0])^^(piecewise(constants[2] > constants[3], constants[0], NAN)^^(constants[4]^^piecewise(constants[2] > constants[3], constants[0], NAN)^^(constants[1] && constants[0]))); + computedConstants[195] = (constants[1] && constants[0])^^(1.0/(piecewise(constants[2] > constants[3], constants[0], NAN)^^(1.0/constants[4])))^^(1.0/piecewise(constants[2] > constants[3], constants[0], NAN))^^(1.0/(constants[1] && constants[0])); + computedConstants[196] = -(constants[1] && constants[0])-piecewise(constants[2] > constants[3], constants[0], NAN); + computedConstants[197] = computedConstants[199]+computedConstants[198]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + rates[0] = 1.0; +} diff --git a/tests/resources/coverage/generator/model_macos.py b/tests/resources/coverage/generator/model_macos.py new file mode 100644 index 0000000000..a8d17e321e --- /dev/null +++ b/tests/resources/coverage/generator/model_macos.py @@ -0,0 +1,620 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 1 +CONSTANT_COUNT = 7 +COMPUTED_CONSTANT_COUNT = 200 +ALGEBRAIC_VARIABLE_COUNT = 2 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} + +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ + {"name": "n", "units": "dimensionless", "component": "my_component"}, + {"name": "m", "units": "dimensionless", "component": "my_component"}, + {"name": "o", "units": "dimensionless", "component": "my_component"}, + {"name": "p", "units": "dimensionless", "component": "my_component"}, + {"name": "q", "units": "dimensionless", "component": "my_component"}, + {"name": "r", "units": "dimensionless", "component": "my_component"}, + {"name": "s", "units": "dimensionless", "component": "my_component"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "eqnEq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnEqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLtCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGtCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAnd", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOr", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXor", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesDirectUnaryMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesIndirectUnaryMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusUnaryParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerSqrt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerSqr", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerCube", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootSqrt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootSqrtOther", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootCube", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAbs", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnExp", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLn", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog10", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLogCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCeiling", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnFloor", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMax", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMaxMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRem", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCos", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTan", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSec", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCsc", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSinh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCosh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTanh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSech", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCsch", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoth", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccos", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArctan", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsec", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccsc", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsinh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccosh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArctanh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsech", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccsch", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccoth", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiece", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePieceOtherwise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiecePiecePiece", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiecePiecePieceOtherwise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnWithPiecewise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnInteger", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnDouble", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnIntegerWithExponent", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnDoubleWithExponent", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTrue", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnFalse", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnExponentiale", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnInfinity", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNotanumber", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForPlusOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForMinusOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForTimesOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForDivideOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForAndOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForOrOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForXorOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForPowerOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant3", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "eqnPlus", "units": "dimensionless", "component": "my_component"} +] + + +def eq_func(x, y): + return 1.0 if x == y else 0.0 + + +def neq_func(x, y): + return 1.0 if x != y else 0.0 + + +def lt_func(x, y): + return 1.0 if x < y else 0.0 + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def gt_func(x, y): + return 1.0 if x > y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def or_func(x, y): + return 1.0 if bool(x) | bool(y) else 0.0 + + +def xor_func(x, y): + return 1.0 if bool(x) ^ bool(y) else 0.0 + + +def not_func(x): + return 1.0 if not bool(x) else 0.0 + + +def min(x, y): + return x if x < y else y + + +def max(x, y): + return x if x > y else y + + +def sec(x): + return 1.0/cos(x) + + +def csc(x): + return 1.0/sin(x) + + +def cot(x): + return 1.0/tan(x) + + +def sech(x): + return 1.0/cosh(x) + + +def csch(x): + return 1.0/sinh(x) + + +def coth(x): + return 1.0/tanh(x) + + +def asec(x): + return acos(1.0/x) + + +def acsc(x): + return asin(1.0/x) + + +def acot(x): + return atan(1.0/x) + + +def asech(x): + one_over_x = 1.0/x + + return log(one_over_x+sqrt(one_over_x*one_over_x-1.0)) + + +def acsch(x): + one_over_x = 1.0/x + + return log(one_over_x+sqrt(one_over_x*one_over_x+1.0)) + + +def acoth(x): + one_over_x = 1.0/x + + return 0.5*log((1.0+one_over_x)/(1.0-one_over_x)) + + +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 create_external_variables_array(): + return [nan]*EXTERNAL_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] + external_variables = data[6] + + algebraic_variables[0] = u[0] + algebraic_variables[1] = u[1] + + f[0] = sin(algebraic_variables[1])+sin(algebraic_variables[0])+states[0]+computed_constants[197]+constants[1]-1.0 + f[1] = -computed_constants[197]-sin(algebraic_variables[0])-computed_constants[198]-computed_constants[199]+sin(algebraic_variables[1])-0.5 + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): + u = [nan]*2 + + u[0] = algebraic_variables[0] + u[1] = algebraic_variables[1] + + u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) + + algebraic_variables[0] = u[0] + algebraic_variables[1] = u[1] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + constants[0] = 1.23 + constants[1] = 123.0 + constants[2] = 1.0e1 + constants[3] = 1.23e1 + constants[4] = 1.0E1 + constants[5] = 1.23E1 + constants[6] = 7.0 + computed_constants[176] = 123.0 + computed_constants[177] = 123.456789 + computed_constants[178] = 123.0e99 + computed_constants[179] = 123.456789e99 + computed_constants[181] = 1.0 + computed_constants[182] = 0.0 + computed_constants[183] = 2.71828182845905 + computed_constants[184] = 3.14159265358979 + computed_constants[185] = inf + computed_constants[186] = nan + computed_constants[199] = 1.0 + computed_constants[198] = 3.0 + algebraic_variables[0] = 0.0 + algebraic_variables[1] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = eq_func(constants[1], constants[0]) + computed_constants[1] = constants[1]/eq_func(constants[0], constants[0]) + computed_constants[2] = neq_func(constants[1], constants[0]) + computed_constants[3] = constants[1]/neq_func(constants[0], constants[2]) + computed_constants[4] = lt_func(constants[1], constants[0]) + computed_constants[5] = constants[1]/lt_func(constants[0], constants[2]) + computed_constants[6] = leq_func(constants[1], constants[0]) + computed_constants[7] = constants[1]/leq_func(constants[0], constants[2]) + computed_constants[8] = gt_func(constants[1], constants[0]) + computed_constants[9] = constants[1]/gt_func(constants[0], constants[2]) + computed_constants[10] = geq_func(constants[1], constants[0]) + computed_constants[11] = constants[1]/geq_func(constants[0], constants[2]) + computed_constants[12] = and_func(constants[1], constants[0]) + computed_constants[13] = and_func(constants[1], and_func(constants[0], constants[2])) + computed_constants[14] = and_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[15] = and_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[16] = and_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[17] = and_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[18] = and_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[19] = and_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[20] = and_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[21] = and_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[22] = and_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[23] = and_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[24] = and_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[25] = and_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[26] = and_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[27] = constants[1]/and_func(constants[0], constants[2]) + computed_constants[28] = or_func(constants[1], constants[0]) + computed_constants[29] = or_func(constants[1], or_func(constants[0], constants[2])) + computed_constants[30] = or_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[31] = or_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[32] = or_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[33] = or_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[34] = or_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[35] = or_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[36] = or_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[37] = or_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[38] = or_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[39] = or_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[40] = or_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[41] = or_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[42] = or_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[43] = constants[1]/or_func(constants[0], constants[2]) + computed_constants[44] = xor_func(constants[1], constants[0]) + computed_constants[45] = xor_func(constants[1], xor_func(constants[0], constants[2])) + computed_constants[46] = xor_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[47] = xor_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[48] = xor_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[49] = xor_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[50] = xor_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[51] = xor_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[52] = xor_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[53] = xor_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[54] = xor_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[55] = xor_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[56] = xor_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[57] = xor_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[58] = xor_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[59] = constants[1]/xor_func(constants[0], constants[2]) + computed_constants[60] = not_func(constants[1]) + computed_constants[61] = constants[1]+constants[0]+constants[2] + computed_constants[62] = lt_func(constants[1], constants[0])+gt_func(constants[2], constants[3]) + computed_constants[63] = constants[1] + computed_constants[64] = constants[1]-constants[0] + computed_constants[65] = lt_func(constants[1], constants[0])-gt_func(constants[2], constants[3]) + computed_constants[66] = lt_func(constants[1], constants[0])-(constants[2]+constants[3]) + computed_constants[67] = lt_func(constants[1], constants[0])-constants[2] + computed_constants[68] = constants[1]-(-constants[0]) + computed_constants[69] = constants[1]-(-constants[0]*constants[2]) + computed_constants[70] = -constants[1] + computed_constants[71] = -lt_func(constants[1], constants[0]) + computed_constants[72] = constants[1]*constants[0] + computed_constants[73] = constants[1]*constants[0]*constants[2] + computed_constants[74] = lt_func(constants[1], constants[0])*gt_func(constants[2], constants[3]) + computed_constants[75] = (constants[1]+constants[0])*gt_func(constants[2], constants[3]) + computed_constants[76] = constants[1]*gt_func(constants[0], constants[2]) + computed_constants[77] = (constants[1]-constants[0])*gt_func(constants[2], constants[3]) + computed_constants[78] = -constants[1]*gt_func(constants[0], constants[2]) + computed_constants[79] = lt_func(constants[1], constants[0])*(constants[2]+constants[3]) + computed_constants[80] = lt_func(constants[1], constants[0])*constants[2] + computed_constants[81] = lt_func(constants[1], constants[0])*(constants[2]-constants[3]) + computed_constants[82] = lt_func(constants[1], constants[0])*-constants[2] + computed_constants[83] = constants[1]/constants[0] + computed_constants[84] = lt_func(constants[1], constants[0])/gt_func(constants[3], constants[2]) + computed_constants[85] = (constants[1]+constants[0])/gt_func(constants[3], constants[2]) + computed_constants[86] = constants[1]/gt_func(constants[2], constants[0]) + computed_constants[87] = (constants[1]-constants[0])/gt_func(constants[3], constants[2]) + computed_constants[88] = -constants[1]/gt_func(constants[2], constants[0]) + computed_constants[89] = lt_func(constants[1], constants[0])/(constants[2]+constants[3]) + computed_constants[90] = lt_func(constants[1], constants[0])/constants[2] + computed_constants[91] = lt_func(constants[1], constants[0])/(constants[2]-constants[3]) + computed_constants[92] = lt_func(constants[1], constants[0])/-constants[2] + computed_constants[93] = lt_func(constants[1], constants[0])/(constants[2]*constants[3]) + computed_constants[94] = lt_func(constants[1], constants[0])/(constants[2]/constants[3]) + computed_constants[95] = sqrt(constants[1]) + computed_constants[96] = pow(constants[1], 2.0) + computed_constants[97] = pow(constants[1], 3.0) + computed_constants[98] = pow(constants[1], constants[0]) + computed_constants[99] = pow(leq_func(constants[1], constants[0]), geq_func(constants[2], constants[3])) + computed_constants[100] = pow(constants[1]+constants[0], geq_func(constants[2], constants[3])) + computed_constants[101] = pow(constants[1], geq_func(constants[0], constants[2])) + computed_constants[102] = pow(constants[1]-constants[0], geq_func(constants[2], constants[3])) + computed_constants[103] = pow(-constants[1], geq_func(constants[0], constants[2])) + computed_constants[104] = pow(constants[1]*constants[0], geq_func(constants[2], constants[3])) + computed_constants[105] = pow(constants[1]/constants[0], geq_func(constants[2], constants[3])) + computed_constants[106] = pow(leq_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[107] = pow(leq_func(constants[1], constants[0]), constants[2]) + computed_constants[108] = pow(leq_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[109] = pow(leq_func(constants[1], constants[0]), -constants[2]) + computed_constants[110] = pow(leq_func(constants[1], constants[0]), constants[2]*constants[3]) + computed_constants[111] = pow(leq_func(constants[1], constants[0]), constants[2]/constants[3]) + computed_constants[112] = pow(leq_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[113] = pow(leq_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[114] = sqrt(constants[1]) + computed_constants[115] = sqrt(constants[1]) + computed_constants[116] = pow(constants[1], 1.0/3.0) + computed_constants[117] = pow(constants[1], 1.0/constants[0]) + computed_constants[118] = pow(lt_func(constants[1], constants[0]), 1.0/gt_func(constants[3], constants[2])) + computed_constants[119] = pow(constants[1]+constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[120] = pow(constants[1], 1.0/gt_func(constants[2], constants[0])) + computed_constants[121] = pow(constants[1]-constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[122] = pow(-constants[1], 1.0/gt_func(constants[2], constants[0])) + computed_constants[123] = pow(constants[1]*constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[124] = pow(constants[1]/constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[125] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]+constants[3])) + computed_constants[126] = pow(lt_func(constants[1], constants[0]), 1.0/constants[2]) + computed_constants[127] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]-constants[3])) + computed_constants[128] = pow(lt_func(constants[1], constants[0]), 1.0/-constants[2]) + computed_constants[129] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]*constants[3])) + computed_constants[130] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]/constants[3])) + computed_constants[131] = pow(lt_func(constants[1], constants[0]), 1.0/pow(constants[2], constants[3])) + computed_constants[132] = pow(lt_func(constants[1], constants[0]), 1.0/pow(constants[2], 1.0/constants[3])) + computed_constants[133] = fabs(constants[1]) + computed_constants[134] = exp(constants[1]) + computed_constants[135] = log(constants[1]) + computed_constants[136] = log10(constants[1]) + computed_constants[137] = log(constants[1])/log(2.0) + computed_constants[138] = log10(constants[1]) + computed_constants[139] = log(constants[1])/log(constants[0]) + computed_constants[140] = ceil(constants[1]) + computed_constants[141] = floor(constants[1]) + computed_constants[142] = min(constants[1], constants[0]) + computed_constants[143] = min(constants[1], min(constants[0], constants[2])) + computed_constants[144] = max(constants[1], constants[0]) + computed_constants[145] = max(constants[1], max(constants[0], constants[2])) + computed_constants[146] = fmod(constants[1], constants[0]) + computed_constants[147] = sin(constants[1]) + computed_constants[148] = cos(constants[1]) + computed_constants[149] = tan(constants[1]) + computed_constants[150] = sec(constants[1]) + computed_constants[151] = csc(constants[1]) + computed_constants[152] = cot(constants[1]) + computed_constants[153] = sinh(constants[1]) + computed_constants[154] = cosh(constants[1]) + computed_constants[155] = tanh(constants[1]) + computed_constants[156] = sech(constants[1]) + computed_constants[157] = csch(constants[1]) + computed_constants[158] = coth(constants[1]) + computed_constants[159] = asin(constants[1]) + computed_constants[160] = acos(constants[1]) + computed_constants[161] = atan(constants[1]) + computed_constants[162] = asec(constants[1]) + computed_constants[163] = acsc(constants[1]) + computed_constants[164] = acot(constants[1]) + computed_constants[165] = asinh(constants[1]) + computed_constants[166] = acosh(constants[1]) + computed_constants[167] = atanh(constants[1]/2.0) + computed_constants[168] = asech(constants[1]) + computed_constants[169] = acsch(constants[1]) + computed_constants[170] = acoth(2.0*constants[1]) + computed_constants[171] = constants[1] if gt_func(constants[1], constants[0]) else nan + computed_constants[172] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] + computed_constants[173] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan + computed_constants[174] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] + computed_constants[175] = 123.0+(constants[1] if gt_func(constants[1], constants[0]) else nan) + computed_constants[180] = constants[1] + computed_constants[187] = and_func(constants[1], constants[0])+(constants[0] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) + computed_constants[188] = and_func(constants[1], constants[0])-((constants[0] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[0] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) + computed_constants[189] = and_func(constants[1], constants[0])*(constants[0] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[0] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) + computed_constants[190] = and_func(constants[1], constants[0])/((constants[0] if gt_func(constants[2], constants[3]) else nan)/(constants[4]/(constants[0] if gt_func(constants[2], constants[3]) else nan))) + computed_constants[191] = and_func(or_func(constants[1], constants[0]), and_func(xor_func(constants[1], constants[0]), and_func(constants[0] if gt_func(constants[2], constants[3]) else nan, and_func(and_func(and_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[1], constants[0])), or_func(constants[1], constants[0]))))) + computed_constants[192] = or_func(and_func(constants[1], constants[0]), or_func(xor_func(constants[1], constants[0]), or_func(constants[0] if gt_func(constants[2], constants[3]) else nan, or_func(or_func(or_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[1], constants[0])), and_func(constants[1], constants[0]))))) + computed_constants[193] = xor_func(and_func(constants[1], constants[0]), xor_func(or_func(constants[1], constants[0]), xor_func(constants[0] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), or_func(constants[1], constants[0])), and_func(constants[1], constants[0]))))) + computed_constants[194] = pow(and_func(constants[1], constants[0]), pow(constants[0] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), and_func(constants[1], constants[0])))) + computed_constants[195] = pow(pow(pow(and_func(constants[1], constants[0]), 1.0/pow(constants[0] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[0] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[1], constants[0])) + computed_constants[196] = -and_func(constants[1], constants[0])-(constants[0] if gt_func(constants[2], constants[3]) else nan) + computed_constants[197] = computed_constants[199]+computed_constants[198] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + rates[0] = 1.0 + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model_windows.c similarity index 98% rename from tests/resources/coverage/generator/model.c rename to tests/resources/coverage/generator/model_windows.c index 7783cbf3ab..6f774daddb 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model_windows.c @@ -10,7 +10,7 @@ const char LIBCELLML_VERSION[] = "0.7.0"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 7; -const size_t COMPUTED_CONSTANT_COUNT = 199; +const size_t COMPUTED_CONSTANT_COUNT = 200; const size_t ALGEBRAIC_VARIABLE_COUNT = 2; const size_t EXTERNAL_VARIABLE_COUNT = 1; @@ -228,6 +228,7 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"eqnCoverageForPowerOperator", "dimensionless", "my_component"}, {"eqnCoverageForRootOperator", "dimensionless", "my_component"}, {"eqnCoverageForMinusUnary", "dimensionless", "my_component"}, + {"eqnComputedConstant3", "dimensionless", "my_component"}, {"eqnComputedConstant2", "dimensionless", "my_component"}, {"eqnComputedConstant1", "dimensionless", "my_component"} }; @@ -408,8 +409,8 @@ void objectiveFunction0(double *u, double *f, void *data) algebraicVariables[0] = u[0]; algebraicVariables[1] = u[1]; - f[0] = algebraicVariables[1]+algebraicVariables[0]+states[0]-0.0; - f[1] = algebraicVariables[1]-algebraicVariables[0]-(computedConstants[198]+computedConstants[197]); + f[0] = constants[1]+sin(algebraicVariables[1])+computedConstants[197]+states[0]+sin(algebraicVariables[0])-1.0; + f[1] = sin(algebraicVariables[1])-computedConstants[197]-computedConstants[198]-computedConstants[199]-sin(algebraicVariables[0])-0.5; } void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) @@ -446,10 +447,10 @@ void initialiseArrays(double *states, double *rates, double *constants, double * computedConstants[184] = 3.14159265358979; computedConstants[185] = INFINITY; computedConstants[186] = NAN; - computedConstants[198] = 1.0; - computedConstants[197] = 3.0; - algebraicVariables[0] = 2.0; - algebraicVariables[1] = 1.0; + computedConstants[199] = 1.0; + computedConstants[198] = 3.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; } void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) @@ -640,7 +641,8 @@ void computeComputedConstants(double voi, double *states, double *rates, double computedConstants[193] = xor(constants[1] && constants[0], xor(constants[1] || constants[0], xor((constants[2] > constants[3])?constants[0]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] || constants[0]), constants[1] && constants[0])))); computedConstants[194] = pow(constants[1] && constants[0], pow((constants[2] > constants[3])?constants[0]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] && constants[0]))); computedConstants[195] = pow(pow(pow(constants[1] && constants[0], 1.0/pow((constants[2] > constants[3])?constants[0]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[0]:NAN)), 1.0/(constants[1] && constants[0])); - computedConstants[196] = -(constants[1] && constants[0])+-((constants[2] > constants[3])?constants[0]:NAN); + computedConstants[196] = -(constants[1] && constants[0])-((constants[2] > constants[3])?constants[0]:NAN); + computedConstants[197] = computedConstants[199]+computedConstants[198]; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model_windows.out similarity index 97% rename from tests/resources/coverage/generator/model.out rename to tests/resources/coverage/generator/model_windows.out index e540f965ef..55247ea825 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model_windows.out @@ -104,8 +104,8 @@ void objectiveFunction0(double *u, double *f, void *data) algebraicVariables[0] = u[0]; algebraicVariables[1] = u[1]; - f[0] = algebraicVariables[1]+algebraicVariables[0]+states[0]-0.0; - f[1] = algebraicVariables[1]-algebraicVariables[0]-(computedConstants[198]+computedConstants[197]); + f[0] = constants[1]+sin(algebraicVariables[1])+computedConstants[197]+states[0]+sin(algebraicVariables[0])-1.0; + f[1] = sin(algebraicVariables[1])-computedConstants[197]-computedConstants[198]-computedConstants[199]-sin(algebraicVariables[0])-0.5; } void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) @@ -310,7 +310,8 @@ void computeComputedConstants(double voi, double *states, double *rates, double computedConstants[193] = (constants[1] && constants[0])^(constants[1] || constants[0])^piecewise(constants[2] > constants[3], constants[0], NAN)^constants[4]^piecewise(constants[2] > constants[3], constants[0], NAN)^(constants[1] || constants[0])^(constants[1] && constants[0]); computedConstants[194] = (constants[1] && constants[0])^^(piecewise(constants[2] > constants[3], constants[0], NAN)^^(constants[4]^^piecewise(constants[2] > constants[3], constants[0], NAN)^^(constants[1] && constants[0]))); computedConstants[195] = (constants[1] && constants[0])^^(1.0/(piecewise(constants[2] > constants[3], constants[0], NAN)^^(1.0/constants[4])))^^(1.0/piecewise(constants[2] > constants[3], constants[0], NAN))^^(1.0/(constants[1] && constants[0])); - computedConstants[196] = -(constants[1] && constants[0])+-piecewise(constants[2] > constants[3], constants[0], NAN); + computedConstants[196] = -(constants[1] && constants[0])-piecewise(constants[2] > constants[3], constants[0], NAN); + computedConstants[197] = computedConstants[199]+computedConstants[198]; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model_windows.py similarity index 98% rename from tests/resources/coverage/generator/model.py rename to tests/resources/coverage/generator/model_windows.py index 0342250d6b..9da40a047d 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model_windows.py @@ -9,7 +9,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 7 -COMPUTED_CONSTANT_COUNT = 199 +COMPUTED_CONSTANT_COUNT = 200 ALGEBRAIC_VARIABLE_COUNT = 2 EXTERNAL_VARIABLE_COUNT = 1 @@ -227,6 +227,7 @@ {"name": "eqnCoverageForPowerOperator", "units": "dimensionless", "component": "my_component"}, {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component"}, {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant3", "units": "dimensionless", "component": "my_component"}, {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component"}, {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component"} ] @@ -378,8 +379,8 @@ def objective_function_0(u, f, data): algebraic_variables[0] = u[0] algebraic_variables[1] = u[1] - f[0] = algebraic_variables[1]+algebraic_variables[0]+states[0]-0.0 - f[1] = algebraic_variables[1]-algebraic_variables[0]-(computed_constants[198]+computed_constants[197]) + f[0] = constants[1]+sin(algebraic_variables[1])+computed_constants[197]+states[0]+sin(algebraic_variables[0])-1.0 + f[1] = sin(algebraic_variables[1])-computed_constants[197]-computed_constants[198]-computed_constants[199]-sin(algebraic_variables[0])-0.5 def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): @@ -413,10 +414,10 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va computed_constants[184] = 3.14159265358979 computed_constants[185] = inf computed_constants[186] = nan - computed_constants[198] = 1.0 - computed_constants[197] = 3.0 - algebraic_variables[0] = 2.0 - algebraic_variables[1] = 1.0 + computed_constants[199] = 1.0 + computed_constants[198] = 3.0 + algebraic_variables[0] = 0.0 + algebraic_variables[1] = 0.0 def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): @@ -606,7 +607,8 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants computed_constants[193] = xor_func(and_func(constants[1], constants[0]), xor_func(or_func(constants[1], constants[0]), xor_func(constants[0] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), or_func(constants[1], constants[0])), and_func(constants[1], constants[0]))))) computed_constants[194] = pow(and_func(constants[1], constants[0]), pow(constants[0] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), and_func(constants[1], constants[0])))) computed_constants[195] = pow(pow(pow(and_func(constants[1], constants[0]), 1.0/pow(constants[0] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[0] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[1], constants[0])) - computed_constants[196] = -and_func(constants[1], constants[0])+-(constants[0] if gt_func(constants[2], constants[3]) else nan) + computed_constants[196] = -and_func(constants[1], constants[0])-(constants[0] if gt_func(constants[2], constants[3]) else nan) + computed_constants[197] = computed_constants[199]+computed_constants[198] def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.cellml b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.cellml index ac8e6388ad..f0452cedfb 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.cellml +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.cellml @@ -2,7 +2,7 @@ - + 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_linux.c similarity index 64% rename from tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c rename to tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_linux.c index 9e493d866b..410d20d34e 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_linux.c @@ -78,45 +78,10 @@ void deleteArray(double *array) free(array); } -typedef struct { - double *constants; - double *computedConstants; - double *algebraicVariables; - double *externalVariables; -} RootFindingInfo; - -extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), - double *u, size_t n, void *data); - -void objectiveFunction0(double *u, double *f, void *data) -{ - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[0] = u[0]; - - f[0] = algebraicVariables[0]+computedConstants[0]-(externalVariables[0]+computedConstants[1]); -} - -void findRoot0(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[0]; - - nlaSolve(objectiveFunction0, u, 1, &rfi); - - algebraicVariables[0] = u[0]; -} - void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { computedConstants[0] = 3.0; computedConstants[1] = 7.0; - algebraicVariables[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants, double *algebraicVariables) @@ -126,5 +91,5 @@ void computeComputedConstants(double *constants, double *computedConstants, doub void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { externalVariables[0] = externalVariable(constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot0(constants, computedConstants, algebraicVariables, externalVariables); + algebraicVariables[0] = externalVariables[0]+computedConstants[1]-computedConstants[0]; } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_linux.py similarity index 66% rename from tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py rename to tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_linux.py index 8ca04a838d..9ce6181d98 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_linux.py @@ -45,34 +45,9 @@ def create_external_variables_array(): return [nan]*EXTERNAL_VARIABLE_COUNT -from nlasolver import nla_solve - - -def objective_function_0(u, f, data): - constants = data[0] - computed_constants = data[1] - algebraic_variables = data[2] - external_variables = data[3] - - algebraic_variables[0] = u[0] - - f[0] = algebraic_variables[0]+computed_constants[0]-(external_variables[0]+computed_constants[1]) - - -def find_root_0(constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[0] = u[0] - - def initialise_arrays(constants, computed_constants, algebraic_variables): computed_constants[0] = 3.0 computed_constants[1] = 7.0 - algebraic_variables[0] = 1.0 def compute_computed_constants(constants, computed_constants, algebraic_variables): @@ -81,4 +56,4 @@ def compute_computed_constants(constants, computed_constants, algebraic_variable def compute_variables(constants, computed_constants, algebraic_variables, external_variables, external_variable): external_variables[0] = external_variable(constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_0(constants, computed_constants, algebraic_variables, external_variables) + algebraic_variables[0] = external_variables[0]+computed_constants[1]-computed_constants[0] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_macos.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_macos.c new file mode 100644 index 0000000000..410d20d34e --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_macos.c @@ -0,0 +1,95 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.external.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 2; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"b", "dimensionless", "my_algebraic_eqn"}, + {"d", "dimensionless", "my_algebraic_eqn"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"a", "dimensionless", "my_algebraic_eqn"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"c", "dimensionless", "my_algebraic_eqn"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = 3.0; + computedConstants[1] = 7.0; +} + +void computeComputedConstants(double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + externalVariables[0] = externalVariable(constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = externalVariables[0]+computedConstants[1]-computedConstants[0]; +} diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_macos.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_macos.py new file mode 100644 index 0000000000..9ce6181d98 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_macos.py @@ -0,0 +1,59 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 2 +ALGEBRAIC_VARIABLE_COUNT = 1 +EXTERNAL_VARIABLE_COUNT = 1 + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "b", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "c", "units": "dimensionless", "component": "my_algebraic_eqn"} +] + + +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 create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(constants, computed_constants, algebraic_variables): + computed_constants[0] = 3.0 + computed_constants[1] = 7.0 + + +def compute_computed_constants(constants, computed_constants, algebraic_variables): + pass + + +def compute_variables(constants, computed_constants, algebraic_variables, external_variables, external_variable): + external_variables[0] = external_variable(constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[0] = external_variables[0]+computed_constants[1]-computed_constants[0] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_windows.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_windows.c new file mode 100644 index 0000000000..10e3cfdd80 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_windows.c @@ -0,0 +1,95 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.external.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 2; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"b", "dimensionless", "my_algebraic_eqn"}, + {"d", "dimensionless", "my_algebraic_eqn"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"a", "dimensionless", "my_algebraic_eqn"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"c", "dimensionless", "my_algebraic_eqn"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = 3.0; + computedConstants[1] = 7.0; +} + +void computeComputedConstants(double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + externalVariables[0] = externalVariable(constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = -computedConstants[0]+externalVariables[0]+computedConstants[1]; +} diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_windows.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_windows.py new file mode 100644 index 0000000000..b7afa36531 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external_windows.py @@ -0,0 +1,59 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 2 +ALGEBRAIC_VARIABLE_COUNT = 1 +EXTERNAL_VARIABLE_COUNT = 1 + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "b", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "c", "units": "dimensionless", "component": "my_algebraic_eqn"} +] + + +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 create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(constants, computed_constants, algebraic_variables): + computed_constants[0] = 3.0 + computed_constants[1] = 7.0 + + +def compute_computed_constants(constants, computed_constants, algebraic_variables): + pass + + +def compute_variables(constants, computed_constants, algebraic_variables, external_variables, external_variable): + external_variables[0] = external_variable(constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[0] = -computed_constants[0]+external_variables[0]+computed_constants[1] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_linux.c similarity index 57% rename from tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c rename to tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_linux.c index a6963d49d1..7975c0737b 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_linux.c @@ -9,8 +9,8 @@ const char VERSION[] = "0.8.0"; const char LIBCELLML_VERSION[] = "0.7.0"; const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 3; -const size_t ALGEBRAIC_VARIABLE_COUNT = 1; +const size_t COMPUTED_CONSTANT_COUNT = 4; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo CONSTANT_INFO[] = { }; @@ -18,11 +18,11 @@ const VariableInfo CONSTANT_INFO[] = { const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"b", "dimensionless", "my_algebraic_eqn"}, {"c", "dimensionless", "my_algebraic_eqn"}, - {"d", "dimensionless", "my_algebraic_eqn"} + {"d", "dimensionless", "my_algebraic_eqn"}, + {"a", "dimensionless", "my_algebraic_eqn"} }; const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { - {"a", "dimensionless", "my_algebraic_eqn"} }; double * createConstantsArray() @@ -63,51 +63,18 @@ void deleteArray(double *array) free(array); } -typedef struct { - 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 *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[0] = u[0]; - - f[0] = algebraicVariables[0]+computedConstants[0]-(computedConstants[1]+computedConstants[2]); -} - -void findRoot0(double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[0]; - - nlaSolve(objectiveFunction0, u, 1, &rfi); - - algebraicVariables[0] = u[0]; -} - void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { computedConstants[0] = 3.0; computedConstants[1] = 5.0; computedConstants[2] = 7.0; - algebraicVariables[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants, double *algebraicVariables) { + computedConstants[3] = computedConstants[1]+computedConstants[2]-computedConstants[0]; } void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) { - findRoot0(constants, computedConstants, 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_linux.py similarity index 61% rename from tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py rename to tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_linux.py index 866fefc01b..a5d0011dac 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_linux.py @@ -8,8 +8,8 @@ LIBCELLML_VERSION = "0.7.0" CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 3 -ALGEBRAIC_VARIABLE_COUNT = 1 +COMPUTED_CONSTANT_COUNT = 4 +ALGEBRAIC_VARIABLE_COUNT = 0 CONSTANT_INFO = [ ] @@ -17,11 +17,11 @@ COMPUTED_CONSTANT_INFO = [ {"name": "b", "units": "dimensionless", "component": "my_algebraic_eqn"}, {"name": "c", "units": "dimensionless", "component": "my_algebraic_eqn"}, - {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn"} + {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} ] ALGEBRAIC_VARIABLE_INFO = [ - {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} ] @@ -37,39 +37,15 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -from nlasolver import nla_solve - - -def objective_function_0(u, f, data): - constants = data[0] - computed_constants = data[1] - algebraic_variables = data[2] - - algebraic_variables[0] = u[0] - - f[0] = algebraic_variables[0]+computed_constants[0]-(computed_constants[1]+computed_constants[2]) - - -def find_root_0(constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [constants, computed_constants, algebraic_variables]) - - algebraic_variables[0] = u[0] - - def initialise_arrays(constants, computed_constants, algebraic_variables): computed_constants[0] = 3.0 computed_constants[1] = 5.0 computed_constants[2] = 7.0 - algebraic_variables[0] = 1.0 def compute_computed_constants(constants, computed_constants, algebraic_variables): - pass + computed_constants[3] = computed_constants[1]+computed_constants[2]-computed_constants[0] def compute_variables(constants, computed_constants, algebraic_variables): - find_root_0(constants, computed_constants, algebraic_variables) + pass diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_macos.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_macos.c new file mode 100644 index 0000000000..7975c0737b --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_macos.c @@ -0,0 +1,80 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 4; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"b", "dimensionless", "my_algebraic_eqn"}, + {"c", "dimensionless", "my_algebraic_eqn"}, + {"d", "dimensionless", "my_algebraic_eqn"}, + {"a", "dimensionless", "my_algebraic_eqn"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { +}; + +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 *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = 3.0; + computedConstants[1] = 5.0; + computedConstants[2] = 7.0; +} + +void computeComputedConstants(double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[3] = computedConstants[1]+computedConstants[2]-computedConstants[0]; +} + +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_macos.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_macos.py new file mode 100644 index 0000000000..a5d0011dac --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_macos.py @@ -0,0 +1,51 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 4 +ALGEBRAIC_VARIABLE_COUNT = 0 + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "b", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "c", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} +] + +ALGEBRAIC_VARIABLE_INFO = [ +] + + +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(constants, computed_constants, algebraic_variables): + computed_constants[0] = 3.0 + computed_constants[1] = 5.0 + computed_constants[2] = 7.0 + + +def compute_computed_constants(constants, computed_constants, algebraic_variables): + computed_constants[3] = computed_constants[1]+computed_constants[2]-computed_constants[0] + + +def compute_variables(constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_windows.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_windows.c new file mode 100644 index 0000000000..f2da1dc95c --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_windows.c @@ -0,0 +1,80 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 4; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"b", "dimensionless", "my_algebraic_eqn"}, + {"c", "dimensionless", "my_algebraic_eqn"}, + {"d", "dimensionless", "my_algebraic_eqn"}, + {"a", "dimensionless", "my_algebraic_eqn"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { +}; + +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 *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = 3.0; + computedConstants[1] = 5.0; + computedConstants[2] = 7.0; +} + +void computeComputedConstants(double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[3] = -computedConstants[0]+computedConstants[1]+computedConstants[2]; +} + +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_windows.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_windows.py new file mode 100644 index 0000000000..052896e9db --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model_windows.py @@ -0,0 +1,51 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 4 +ALGEBRAIC_VARIABLE_COUNT = 0 + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "b", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "c", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} +] + +ALGEBRAIC_VARIABLE_INFO = [ +] + + +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(constants, computed_constants, algebraic_variables): + computed_constants[0] = 3.0 + computed_constants[1] = 5.0 + computed_constants[2] = 7.0 + + +def compute_computed_constants(constants, computed_constants, algebraic_variables): + computed_constants[3] = -computed_constants[0]+computed_constants[1]+computed_constants[2] + + +def compute_variables(constants, computed_constants, algebraic_variables): + 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 c10c585b0b..53b110c052 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 @@ -9,21 +9,21 @@ const char VERSION[] = "0.8.0"; const char LIBCELLML_VERSION[] = "0.7.0"; const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_VARIABLE_COUNT = 3; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { -}; - -const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { {"z", "dimensionless", "my_algebraic_system"}, {"y", "dimensionless", "my_algebraic_system"}, {"x", "dimensionless", "my_algebraic_system"} }; +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { +}; + double * createConstantsArray() { double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); @@ -62,51 +62,11 @@ void deleteArray(double *array) free(array); } -typedef struct { - 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 *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[0] = u[0]; - algebraicVariables[1] = u[1]; - algebraicVariables[2] = u[2]; - - f[0] = 2.0*algebraicVariables[2]+algebraicVariables[1]-2.0*algebraicVariables[0]-(-1.0); - f[1] = 3.0*algebraicVariables[2]-3.0*algebraicVariables[1]-algebraicVariables[0]-5.0; - f[2] = algebraicVariables[2]-2.0*algebraicVariables[1]+3.0*algebraicVariables[0]-6.0; -} - -void findRoot0(double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { constants, computedConstants, algebraicVariables }; - double u[3]; - - u[0] = algebraicVariables[0]; - u[1] = algebraicVariables[1]; - u[2] = algebraicVariables[2]; - - nlaSolve(objectiveFunction0, u, 3, &rfi); - - algebraicVariables[0] = u[0]; - algebraicVariables[1] = u[1]; - algebraicVariables[2] = u[2]; -} - void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { - algebraicVariables[0] = 1.0; - algebraicVariables[1] = 1.0; - algebraicVariables[2] = 1.0; + computedConstants[2] = 1.0; + computedConstants[1] = -1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants, double *algebraicVariables) @@ -115,5 +75,4 @@ void computeComputedConstants(double *constants, double *computedConstants, doub void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) { - findRoot0(constants, computedConstants, algebraicVariables); } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.cellml b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.cellml index 19f8308709..285f351fee 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.cellml +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.cellml @@ -2,18 +2,18 @@ - - - + + + 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 8c1791e35e..50af054372 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 @@ -8,21 +8,21 @@ LIBCELLML_VERSION = "0.7.0" CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_VARIABLE_COUNT = 3 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 0 CONSTANT_INFO = [ ] COMPUTED_CONSTANT_INFO = [ -] - -ALGEBRAIC_VARIABLE_INFO = [ {"name": "z", "units": "dimensionless", "component": "my_algebraic_system"}, {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"}, {"name": "x", "units": "dimensionless", "component": "my_algebraic_system"} ] +ALGEBRAIC_VARIABLE_INFO = [ +] + def create_constants_array(): return [nan]*CONSTANT_COUNT @@ -36,41 +36,10 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -from nlasolver import nla_solve - - -def objective_function_0(u, f, data): - constants = data[0] - computed_constants = data[1] - algebraic_variables = data[2] - - algebraic_variables[0] = u[0] - algebraic_variables[1] = u[1] - algebraic_variables[2] = u[2] - - f[0] = 2.0*algebraic_variables[2]+algebraic_variables[1]-2.0*algebraic_variables[0]-(-1.0) - f[1] = 3.0*algebraic_variables[2]-3.0*algebraic_variables[1]-algebraic_variables[0]-5.0 - f[2] = algebraic_variables[2]-2.0*algebraic_variables[1]+3.0*algebraic_variables[0]-6.0 - - -def find_root_0(constants, computed_constants, algebraic_variables): - u = [nan]*3 - - u[0] = algebraic_variables[0] - u[1] = algebraic_variables[1] - u[2] = algebraic_variables[2] - - u = nla_solve(objective_function_0, u, 3, [constants, computed_constants, algebraic_variables]) - - algebraic_variables[0] = u[0] - algebraic_variables[1] = u[1] - algebraic_variables[2] = u[2] - - def initialise_arrays(constants, computed_constants, algebraic_variables): - algebraic_variables[0] = 1.0 - algebraic_variables[1] = 1.0 - algebraic_variables[2] = 1.0 + computed_constants[2] = 1.0 + computed_constants[1] = -1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants, algebraic_variables): @@ -78,4 +47,4 @@ def compute_computed_constants(constants, computed_constants, algebraic_variable def compute_variables(constants, computed_constants, algebraic_variables): - find_root_0(constants, computed_constants, algebraic_variables) + 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 735e604e36..deadd07f70 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 @@ -9,8 +9,8 @@ const char VERSION[] = "0.8.0"; const char LIBCELLML_VERSION[] = "0.7.0"; const size_t CONSTANT_COUNT = 2; -const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_VARIABLE_COUNT = 3; +const size_t COMPUTED_CONSTANT_COUNT = 4; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo CONSTANT_INFO[] = { {"y", "dimensionless", "my_algebraic_system"}, @@ -18,13 +18,13 @@ const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"c", "dimensionless", "my_algebraic_system"}, + {"b", "dimensionless", "my_algebraic_system"}, + {"d", "dimensionless", "my_algebraic_system"}, {"a", "dimensionless", "my_algebraic_system"} }; const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { - {"c", "dimensionless", "my_algebraic_system"}, - {"b", "dimensionless", "my_algebraic_system"}, - {"d", "dimensionless", "my_algebraic_system"} }; double * createConstantsArray() @@ -65,57 +65,20 @@ void deleteArray(double *array) free(array); } -typedef struct { - 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 *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[0] = u[0]; - algebraicVariables[1] = u[1]; - - f[0] = 3.0*computedConstants[0]+2.0*algebraicVariables[1]+algebraicVariables[0]-57.0; - f[1] = computedConstants[0]+3.0*algebraicVariables[1]-algebraicVariables[0]-19.0; -} - -void findRoot0(double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { constants, computedConstants, algebraicVariables }; - double u[2]; - - u[0] = algebraicVariables[0]; - u[1] = algebraicVariables[1]; - - nlaSolve(objectiveFunction0, u, 2, &rfi); - - algebraicVariables[0] = u[0]; - algebraicVariables[1] = u[1]; -} - void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 5.0; constants[1] = 3.0; - algebraicVariables[0] = 1.0; - algebraicVariables[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants, double *algebraicVariables) { - computedConstants[0] = 3.0*constants[1]+constants[0]; + computedConstants[3] = 3.0*constants[1]+constants[0]; + computedConstants[0] = 26.6-1.4*computedConstants[3]; + computedConstants[1] = 28.5-0.5*computedConstants[0]-1.5*computedConstants[3]; + computedConstants[2] = computedConstants[1]+computedConstants[0]; } void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) { - findRoot0(constants, computedConstants, algebraicVariables); - algebraicVariables[2] = algebraicVariables[1]+algebraicVariables[0]; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.cellml b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.cellml index 9a82849c6e..eab0cb0162 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.cellml +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.cellml @@ -2,10 +2,10 @@ - - + + 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 9ff130ba15..eb2976bbe2 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 @@ -8,8 +8,8 @@ LIBCELLML_VERSION = "0.7.0" CONSTANT_COUNT = 2 -COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_VARIABLE_COUNT = 3 +COMPUTED_CONSTANT_COUNT = 4 +ALGEBRAIC_VARIABLE_COUNT = 0 CONSTANT_INFO = [ {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"}, @@ -17,13 +17,13 @@ ] COMPUTED_CONSTANT_INFO = [ + {"name": "c", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "b", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "d", "units": "dimensionless", "component": "my_algebraic_system"}, {"name": "a", "units": "dimensionless", "component": "my_algebraic_system"} ] ALGEBRAIC_VARIABLE_INFO = [ - {"name": "c", "units": "dimensionless", "component": "my_algebraic_system"}, - {"name": "b", "units": "dimensionless", "component": "my_algebraic_system"}, - {"name": "d", "units": "dimensionless", "component": "my_algebraic_system"} ] @@ -39,44 +39,17 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -from nlasolver import nla_solve - - -def objective_function_0(u, f, data): - constants = data[0] - computed_constants = data[1] - algebraic_variables = data[2] - - algebraic_variables[0] = u[0] - algebraic_variables[1] = u[1] - - f[0] = 3.0*computed_constants[0]+2.0*algebraic_variables[1]+algebraic_variables[0]-57.0 - f[1] = computed_constants[0]+3.0*algebraic_variables[1]-algebraic_variables[0]-19.0 - - -def find_root_0(constants, computed_constants, algebraic_variables): - u = [nan]*2 - - u[0] = algebraic_variables[0] - u[1] = algebraic_variables[1] - - u = nla_solve(objective_function_0, u, 2, [constants, computed_constants, algebraic_variables]) - - algebraic_variables[0] = u[0] - algebraic_variables[1] = u[1] - - def initialise_arrays(constants, computed_constants, algebraic_variables): constants[0] = 5.0 constants[1] = 3.0 - algebraic_variables[0] = 1.0 - algebraic_variables[1] = 1.0 def compute_computed_constants(constants, computed_constants, algebraic_variables): - computed_constants[0] = 3.0*constants[1]+constants[0] + computed_constants[3] = 3.0*constants[1]+constants[0] + computed_constants[0] = 26.6-1.4*computed_constants[3] + computed_constants[1] = 28.5-0.5*computed_constants[0]-1.5*computed_constants[3] + computed_constants[2] = computed_constants[1]+computed_constants[0] def compute_variables(constants, computed_constants, algebraic_variables): - find_root_0(constants, computed_constants, algebraic_variables) - algebraic_variables[2] = algebraic_variables[1]+algebraic_variables[0] + pass 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 bf2accd13b..e713b66b7d 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 @@ -9,8 +9,8 @@ const char VERSION[] = "0.8.0"; const char LIBCELLML_VERSION[] = "0.7.0"; const size_t CONSTANT_COUNT = 2; -const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_VARIABLE_COUNT = 3; +const size_t COMPUTED_CONSTANT_COUNT = 4; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo CONSTANT_INFO[] = { {"y", "dimensionless", "my_algebraic_system"}, @@ -18,15 +18,15 @@ const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"a", "dimensionless", "my_algebraic_system"} -}; - -const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"a", "dimensionless", "my_algebraic_system"}, {"c", "dimensionless", "my_algebraic_system"}, {"b", "dimensionless", "my_algebraic_system"}, {"d", "dimensionless", "my_algebraic_system"} }; +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { +}; + double * createConstantsArray() { double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); @@ -65,57 +65,20 @@ void deleteArray(double *array) free(array); } -typedef struct { - 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 *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[0] = u[0]; - algebraicVariables[1] = u[1]; - - f[0] = 3.0*computedConstants[0]+2.0*algebraicVariables[1]+algebraicVariables[0]-57.0; - f[1] = computedConstants[0]+3.0*algebraicVariables[1]-algebraicVariables[0]-19.0; -} - -void findRoot0(double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { constants, computedConstants, algebraicVariables }; - double u[2]; - - u[0] = algebraicVariables[0]; - u[1] = algebraicVariables[1]; - - nlaSolve(objectiveFunction0, u, 2, &rfi); - - algebraicVariables[0] = u[0]; - algebraicVariables[1] = u[1]; -} - void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 5.0; constants[1] = 3.0; - algebraicVariables[0] = 1.0; - algebraicVariables[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants, double *algebraicVariables) { computedConstants[0] = 3.0*constants[1]+constants[0]; + computedConstants[1] = 26.6-1.4*computedConstants[0]; + computedConstants[2] = 28.5-0.5*computedConstants[1]-1.5*computedConstants[0]; + computedConstants[3] = computedConstants[2]+computedConstants[1]; } void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) { - findRoot0(constants, computedConstants, algebraicVariables); - algebraicVariables[2] = algebraicVariables[1]+algebraicVariables[0]; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.cellml b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.cellml index 6851b85570..baba364bad 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.cellml +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.cellml @@ -2,10 +2,10 @@ - - + + 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 9ff130ba15..2efadfec99 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 @@ -8,8 +8,8 @@ LIBCELLML_VERSION = "0.7.0" CONSTANT_COUNT = 2 -COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_VARIABLE_COUNT = 3 +COMPUTED_CONSTANT_COUNT = 4 +ALGEBRAIC_VARIABLE_COUNT = 0 CONSTANT_INFO = [ {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"}, @@ -17,15 +17,15 @@ ] COMPUTED_CONSTANT_INFO = [ - {"name": "a", "units": "dimensionless", "component": "my_algebraic_system"} -] - -ALGEBRAIC_VARIABLE_INFO = [ + {"name": "a", "units": "dimensionless", "component": "my_algebraic_system"}, {"name": "c", "units": "dimensionless", "component": "my_algebraic_system"}, {"name": "b", "units": "dimensionless", "component": "my_algebraic_system"}, {"name": "d", "units": "dimensionless", "component": "my_algebraic_system"} ] +ALGEBRAIC_VARIABLE_INFO = [ +] + def create_constants_array(): return [nan]*CONSTANT_COUNT @@ -39,44 +39,17 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -from nlasolver import nla_solve - - -def objective_function_0(u, f, data): - constants = data[0] - computed_constants = data[1] - algebraic_variables = data[2] - - algebraic_variables[0] = u[0] - algebraic_variables[1] = u[1] - - f[0] = 3.0*computed_constants[0]+2.0*algebraic_variables[1]+algebraic_variables[0]-57.0 - f[1] = computed_constants[0]+3.0*algebraic_variables[1]-algebraic_variables[0]-19.0 - - -def find_root_0(constants, computed_constants, algebraic_variables): - u = [nan]*2 - - u[0] = algebraic_variables[0] - u[1] = algebraic_variables[1] - - u = nla_solve(objective_function_0, u, 2, [constants, computed_constants, algebraic_variables]) - - algebraic_variables[0] = u[0] - algebraic_variables[1] = u[1] - - def initialise_arrays(constants, computed_constants, algebraic_variables): constants[0] = 5.0 constants[1] = 3.0 - algebraic_variables[0] = 1.0 - algebraic_variables[1] = 1.0 def compute_computed_constants(constants, computed_constants, algebraic_variables): computed_constants[0] = 3.0*constants[1]+constants[0] + computed_constants[1] = 26.6-1.4*computed_constants[0] + computed_constants[2] = 28.5-0.5*computed_constants[1]-1.5*computed_constants[0] + computed_constants[3] = computed_constants[2]+computed_constants[1] def compute_variables(constants, computed_constants, algebraic_variables): - find_root_0(constants, computed_constants, algebraic_variables) - algebraic_variables[2] = algebraic_variables[1]+algebraic_variables[0] + pass diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index c5ef49f0f2..2838290fb2 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -92,12 +92,12 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - rates[1] = -states[0]*1.0; - rates[0] = states[1]*1.0; + rates[1] = -states[0]; + rates[0] = states[1]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraicVariables[0] = states[0]+5.0*states[0]/3.0+1.0*exp(states[0]/2.0); + algebraicVariables[0] = states[0]+5.0*states[0]/3.0+exp(states[0]/2.0); algebraicVariables[1] = 2.0*states[1]; } diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index 99b507b4be..d176609815 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -57,10 +57,10 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - rates[1] = -states[0]*1.0 - rates[0] = states[1]*1.0 + rates[1] = -states[0] + rates[0] = states[1] def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - algebraic_variables[0] = states[0]+5.0*states[0]/3.0+1.0*exp(states[0]/2.0) + algebraic_variables[0] = states[0]+5.0*states[0]/3.0+exp(states[0]/2.0) algebraic_variables[1] = 2.0*states[1] 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 436c279dac..1f81ae611a 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -90,8 +90,8 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - rates[0] = voi/1.0; - rates[1] = 0.001*voi/1.0; + rates[0] = voi; + rates[1] = 0.001*voi; } 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 fe3cb18118..f8e54df2bb 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -55,8 +55,8 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - rates[0] = voi/1.0 - rates[1] = 0.001*voi/1.0 + rates[0] = voi + rates[1] = 0.001*voi def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): 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 18bed84483..a11bd0dc64 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -93,8 +93,8 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = 5.0; - rates[1] = 1000.0*9.0; - rates[2] = 0.001*13.0; + rates[1] = 9000.0; + rates[2] = 0.013; } 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 fb41f67a9f..062025cda1 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -58,8 +58,8 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = 5.0 - rates[1] = 1000.0*9.0 - rates[2] = 0.001*13.0 + rates[1] = 9000.0 + rates[2] = 0.013 def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): 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 5f9ddff8f1..b30f2b7f3d 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -88,70 +88,6 @@ 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] = constants[0]-(algebraicVariables[0]+algebraicVariables[1]); -} - -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[2] = u[0]; - - f[0] = algebraicVariables[4]-(algebraicVariables[3]+algebraicVariables[2]); -} - -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[2]; - - nlaSolve(objectiveFunction1, u, 1, &rfi); - - algebraicVariables[2] = u[0]; -} - void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; @@ -161,8 +97,6 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[2] = 20.0; constants[3] = 2.0; constants[4] = 10.0; - algebraicVariables[0] = 0.0; - algebraicVariables[2] = 0.0; } void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) @@ -172,19 +106,19 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { algebraicVariables[1] = states[1]+constants[1]; - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + algebraicVariables[0] = constants[0]-algebraicVariables[1]; rates[0] = algebraicVariables[0]; algebraicVariables[3] = constants[3]*algebraicVariables[1]; algebraicVariables[4] = states[0]/constants[2]; - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); + algebraicVariables[2] = algebraicVariables[4]-algebraicVariables[3]; rates[1] = algebraicVariables[2]/constants[4]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { algebraicVariables[1] = states[1]+constants[1]; - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + algebraicVariables[0] = constants[0]-algebraicVariables[1]; algebraicVariables[3] = constants[3]*algebraicVariables[1]; algebraicVariables[4] = states[0]/constants[2]; - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); + algebraicVariables[2] = algebraicVariables[4]-algebraicVariables[3]; } 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 2cd1d0e43a..2c7b7f335b 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -55,55 +55,6 @@ 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] - - algebraic_variables[0] = u[0] - - f[0] = constants[0]-(algebraic_variables[0]+algebraic_variables[1]) - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[2] = u[0] - - f[0] = algebraic_variables[4]-(algebraic_variables[3]+algebraic_variables[2]) - - -def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[2] - - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[2] = u[0] - - def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 states[1] = 0.0 @@ -112,8 +63,6 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[2] = 20.0 constants[3] = 2.0 constants[4] = 10.0 - algebraic_variables[0] = 0.0 - algebraic_variables[2] = 0.0 def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): @@ -122,17 +71,17 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): algebraic_variables[1] = states[1]+constants[1] - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + algebraic_variables[0] = constants[0]-algebraic_variables[1] rates[0] = algebraic_variables[0] algebraic_variables[3] = constants[3]*algebraic_variables[1] algebraic_variables[4] = states[0]/constants[2] - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) + algebraic_variables[2] = algebraic_variables[4]-algebraic_variables[3] rates[1] = algebraic_variables[2]/constants[4] def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): algebraic_variables[1] = states[1]+constants[1] - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + algebraic_variables[0] = constants[0]-algebraic_variables[1] algebraic_variables[3] = constants[3]*algebraic_variables[1] algebraic_variables[4] = states[0]/constants[2] - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) + algebraic_variables[2] = algebraic_variables[4]-algebraic_variables[3] 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 d6f5f774ec..d0345fb4a6 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 @@ -472,7 +472,7 @@ void computeComputedConstants(double voi, double *states, double *rates, double computedConstants[13] = constants[70]*computedConstants[12]; computedConstants[14] = computedConstants[13]*constants[4]/(constants[4]+constants[68]); computedConstants[15] = computedConstants[12]*constants[4]/(constants[4]+constants[68]); - computedConstants[16] = (constants[0] > 0.0)?-1.0-9.898*pow(1.0*constants[0], 0.618)/(pow(1.0*constants[0], 0.618)+0.00122423):0.0; + computedConstants[16] = (constants[0] > 0.0)?-1.0-9.898*pow(constants[0], 0.618)/(pow(constants[0], 0.618)+0.00122423):0.0; computedConstants[17] = (constants[1] > 0.0)?7.5:0.0; computedConstants[18] = (constants[1] > 0.0)?1.23:1.0; computedConstants[19] = 0.31*constants[0]/(constants[0]+0.00009); @@ -480,37 +480,37 @@ void computeComputedConstants(double voi, double *states, double *rates, double computedConstants[21] = (constants[1] > 0.0)?-27.0:0.0; computedConstants[22] = (constants[1] > 0.0)?1.2*constants[88]:constants[88]; computedConstants[23] = (constants[1] > 0.0)?-14.0:0.0; - computedConstants[24] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*constants[0], 1.6951))+0.025641; + computedConstants[24] = 3.573159/(1.0+0.0000012155/pow(constants[0], 1.6951))+0.025641; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraicVariables[0] = states[1]; algebraicVariables[47] = ((voi > constants[66]) && (voi < constants[66]+constants[65]))?constants[64]:constants[67]; algebraicVariables[8] = (constants[63] >= 1.0)?algebraicVariables[47]:states[15]; - algebraicVariables[5] = 0.0000185*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0])))*(algebraicVariables[0]-constants[2]*exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraicVariables[1] = computedConstants[0]*log(constants[2]/algebraicVariables[0]); - algebraicVariables[6] = states[16]*computedConstants[14]*(algebraicVariables[8]-algebraicVariables[1])*(1.0-constants[71]); - algebraicVariables[51] = computedConstants[0]*log((constants[2]+0.12*constants[4])/(algebraicVariables[0]+0.12*constants[3])); - algebraicVariables[53] = constants[74]*pow(states[18], 3.0)*(algebraicVariables[8]-algebraicVariables[51]); - algebraicVariables[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraicVariables[8]-algebraicVariables[51]); - algebraicVariables[7] = algebraicVariables[52]+algebraicVariables[53]; - algebraicVariables[4] = computedConstants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraicVariables[0], 1.3), -1.0)*pow(1.0+exp(-(algebraicVariables[8]-algebraicVariables[1]+110.0)/20.0), -1.0); - algebraicVariables[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraicVariables[8]/computedConstants[0])+algebraicVariables[0]/constants[19])+algebraicVariables[0]/constants[18]*(1.0+algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])); - algebraicVariables[13] = states[0]/constants[15]*exp(-constants[14]*algebraicVariables[8]/computedConstants[0])/algebraicVariables[20]; + algebraicVariables[17] = exp(constants[16]*algebraicVariables[8]/(2.0*computedConstants[0])); algebraicVariables[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraicVariables[8]/computedConstants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])); algebraicVariables[14] = constants[5]/constants[22]*exp(constants[21]*algebraicVariables[8]/computedConstants[0])/algebraicVariables[21]; - algebraicVariables[17] = exp(constants[16]*algebraicVariables[8]/(2.0*computedConstants[0])); + algebraicVariables[0] = states[1]; + algebraicVariables[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraicVariables[8]/computedConstants[0])+algebraicVariables[0]/constants[19])+algebraicVariables[0]/constants[18]*(1.0+algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])); algebraicVariables[19] = algebraicVariables[0]/constants[18]*algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])*exp(constants[16]*algebraicVariables[8]/(2.0*computedConstants[0]))/algebraicVariables[20]; + algebraicVariables[13] = states[0]/constants[15]*exp(-constants[14]*algebraicVariables[8]/computedConstants[0])/algebraicVariables[20]; algebraicVariables[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraicVariables[8]/(2.0*computedConstants[0]))/algebraicVariables[21]; algebraicVariables[9] = algebraicVariables[18]*computedConstants[5]*(algebraicVariables[19]+algebraicVariables[13])+algebraicVariables[19]*algebraicVariables[14]*(computedConstants[5]+algebraicVariables[17]); - algebraicVariables[16] = algebraicVariables[0]/(constants[13]+algebraicVariables[0]); algebraicVariables[15] = exp(-constants[16]*algebraicVariables[8]/(2.0*computedConstants[0])); + algebraicVariables[16] = algebraicVariables[0]/(constants[13]+algebraicVariables[0]); algebraicVariables[10] = algebraicVariables[19]*algebraicVariables[16]*(algebraicVariables[18]+algebraicVariables[14])+algebraicVariables[13]*algebraicVariables[18]*(algebraicVariables[16]+algebraicVariables[15]); algebraicVariables[11] = algebraicVariables[17]*algebraicVariables[16]*(algebraicVariables[19]+algebraicVariables[13])+algebraicVariables[15]*algebraicVariables[13]*(computedConstants[5]+algebraicVariables[17]); algebraicVariables[12] = algebraicVariables[15]*computedConstants[5]*(algebraicVariables[18]+algebraicVariables[14])+algebraicVariables[14]*algebraicVariables[17]*(algebraicVariables[16]+algebraicVariables[15]); algebraicVariables[3] = (1.0-constants[12])*constants[11]*(algebraicVariables[11]*algebraicVariables[14]-algebraicVariables[12]*algebraicVariables[13])/(algebraicVariables[12]+algebraicVariables[11]+algebraicVariables[10]+algebraicVariables[9]); - rates[1] = (1.0-constants[7])*-1.0*(algebraicVariables[7]+algebraicVariables[6]+algebraicVariables[5]+3.0*algebraicVariables[4]+3.0*algebraicVariables[3])/(1.0*(computedConstants[3]+computedConstants[2])*constants[6]); + algebraicVariables[1] = computedConstants[0]*log(constants[2]/algebraicVariables[0]); + algebraicVariables[4] = computedConstants[4]*constants[10]*1.0/(1.0+exp((-algebraicVariables[8]+algebraicVariables[1]-110.0)/20.0))/(1.0+pow(constants[8]/algebraicVariables[0], 1.3))/(1.0+pow(constants[9]/constants[4], 1.2)); + algebraicVariables[5] = 0.0000185*constants[77]*algebraicVariables[8]/(computedConstants[0]*(1.0-exp(-algebraicVariables[8]/computedConstants[0])))*(algebraicVariables[0]-constants[2]*exp(-algebraicVariables[8]/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraicVariables[6] = states[16]*computedConstants[14]*(algebraicVariables[8]-algebraicVariables[1])*(1.0-constants[71]); + algebraicVariables[51] = computedConstants[0]*log((constants[2]+0.12*constants[4])/(algebraicVariables[0]+0.12*constants[3])); + algebraicVariables[53] = constants[74]*pow(states[18], 3.0)*(algebraicVariables[8]-algebraicVariables[51]); + algebraicVariables[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraicVariables[8]-algebraicVariables[51]); + algebraicVariables[7] = algebraicVariables[52]+algebraicVariables[53]; + rates[1] = (1.0-constants[7])*(-algebraicVariables[7]-algebraicVariables[6]-algebraicVariables[5]-3.0*algebraicVariables[4]-3.0*algebraicVariables[3])/((computedConstants[3]+computedConstants[2])*constants[6]); algebraicVariables[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])); algebraicVariables[25] = constants[30]/algebraicVariables[24]; algebraicVariables[26] = constants[31]*algebraicVariables[24]; @@ -532,18 +532,18 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[14] = algebraicVariables[36]; algebraicVariables[29] = computedConstants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])); algebraicVariables[28] = (states[0]-states[7])/constants[35]; - rates[7] = 1.0*(algebraicVariables[28]*computedConstants[2]-algebraicVariables[29]*computedConstants[8])/computedConstants[3]-(constants[52]*algebraicVariables[34]+constants[50]*algebraicVariables[31]+constants[51]*algebraicVariables[32]); + rates[7] = (algebraicVariables[28]*computedConstants[2]-algebraicVariables[29]*computedConstants[8])/computedConstants[3]-(constants[52]*algebraicVariables[34]+constants[50]*algebraicVariables[31]+constants[51]*algebraicVariables[32]); + algebraicVariables[37] = 2.0*constants[84]*algebraicVariables[8]/(computedConstants[0]*(1.0-exp(-algebraicVariables[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraicVariables[8]/computedConstants[0]))*states[25]*states[24]; + algebraicVariables[38] = 2.0*constants[77]*algebraicVariables[8]/(computedConstants[0]*(1.0-exp(-algebraicVariables[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraicVariables[8]/computedConstants[0]))*states[23]*states[22]*states[21]; algebraicVariables[22] = constants[25]*states[3]*(states[2]-states[0]); - algebraicVariables[37] = 2.0*constants[84]*algebraicVariables[8]/(computedConstants[0]*(1.0-exp(-1.0*algebraicVariables[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraicVariables[8]/computedConstants[0]))*states[25]*states[24]; - algebraicVariables[38] = 2.0*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; rates[0] = algebraicVariables[22]*computedConstants[9]/computedConstants[2]-((algebraicVariables[38]+algebraicVariables[37]-2.0*algebraicVariables[3])/(2.0*constants[6]*computedConstants[2])+algebraicVariables[28]+constants[52]*algebraicVariables[35]); algebraicVariables[30] = (states[8]-states[2])/constants[38]; rates[8] = algebraicVariables[29]-algebraicVariables[30]*computedConstants[9]/computedConstants[8]; rates[2] = algebraicVariables[30]-(algebraicVariables[22]+constants[53]*algebraicVariables[36]); algebraicVariables[39] = constants[76]*states[20]*states[19]*(algebraicVariables[8]-computedConstants[1]); algebraicVariables[40] = (constants[0] > 0.0)?constants[90]*constants[89]*(algebraicVariables[8]-computedConstants[1])*(1.0+exp((algebraicVariables[8]+20.0)/20.0))*states[32]:0.0; - algebraicVariables[67] = 0.000365*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraicVariables[41] = (algebraicVariables[38]+algebraicVariables[67]+algebraicVariables[5])*(1.0-computedConstants[19])*1.0*computedConstants[18]; + algebraicVariables[67] = 0.000365*constants[77]*algebraicVariables[8]/(computedConstants[0]*(1.0-exp(-algebraicVariables[8]/computedConstants[0])))*(constants[3]-constants[4]*exp(-algebraicVariables[8]/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraicVariables[41] = (algebraicVariables[38]+algebraicVariables[67]+algebraicVariables[5])*(1.0-computedConstants[19])*computedConstants[18]; algebraicVariables[42] = constants[86]*(algebraicVariables[8]-computedConstants[1])*states[27]*states[26]; algebraicVariables[93] = computedConstants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraicVariables[0])); algebraicVariables[43] = computedConstants[22]*(algebraicVariables[8]-algebraicVariables[93])*pow(states[31], 2.0); @@ -553,13 +553,13 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraicVariables[46] = algebraicVariables[45]+algebraicVariables[44]+algebraicVariables[43]+algebraicVariables[42]+algebraicVariables[4]+algebraicVariables[3]+algebraicVariables[7]+algebraicVariables[41]+algebraicVariables[37]+algebraicVariables[40]+algebraicVariables[39]; rates[15] = -algebraicVariables[46]/constants[60]; algebraicVariables[49] = 1.0/(0.36*(algebraicVariables[8]+148.8-computedConstants[16]-computedConstants[17])/(exp(0.066*(algebraicVariables[8]+148.8-computedConstants[16]-computedConstants[17]))-1.0)+0.1*(algebraicVariables[8]+87.3-computedConstants[16]-computedConstants[17])/(1.0-exp(-0.2*(algebraicVariables[8]+87.3-computedConstants[16]-computedConstants[17]))))-0.054; - algebraicVariables[50] = (algebraicVariables[8] < -(80.0-computedConstants[16]-computedConstants[17]-constants[72]))?0.01329+0.99921/(1.0+exp((algebraicVariables[8]+97.134-computedConstants[16]-computedConstants[17]-constants[72])/8.1752)):0.0002501*exp(-(algebraicVariables[8]-computedConstants[16]-computedConstants[17]-constants[72])/12.861); + algebraicVariables[50] = (algebraicVariables[8] < -80.0+computedConstants[16]+computedConstants[17]+constants[72])?0.01329+0.99921/(1.0+exp((algebraicVariables[8]+97.134-computedConstants[16]-computedConstants[17]-constants[72])/8.1752)):0.0002501*exp((-algebraicVariables[8]+computedConstants[16]+computedConstants[17]+constants[72])/12.861); rates[16] = (algebraicVariables[50]-states[16])/algebraicVariables[49]; algebraicVariables[57] = 8000.0*exp(-0.056*(algebraicVariables[8]+66.0)); algebraicVariables[55] = algebraicVariables[8]+41.0; algebraicVariables[56] = (fabs(algebraicVariables[55]) < constants[75])?2000.0:200.0*algebraicVariables[55]/(1.0-exp(-0.1*algebraicVariables[55])); algebraicVariables[58] = 1.0/(algebraicVariables[56]+algebraicVariables[57]); - algebraicVariables[54] = 1.0/(1.0+exp(-(algebraicVariables[8]+42.0504)/8.3106)); + algebraicVariables[54] = 1.0/(1.0+exp((-algebraicVariables[8]-42.0504)/8.3106)); rates[18] = (algebraicVariables[54]-states[18])/algebraicVariables[58]; algebraicVariables[61] = 2000.0/(320.0*exp(-0.1*(algebraicVariables[8]+75.0))+1.0); algebraicVariables[60] = 20.0*exp(-0.125*(algebraicVariables[8]+75.0)); @@ -572,12 +572,12 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraicVariables[65] = 0.59/(1.0+exp((algebraicVariables[8]+60.0)/10.0))+3.05; algebraicVariables[66] = 1.0/(1.0+exp((algebraicVariables[8]+7.5)/10.0)); rates[19] = (algebraicVariables[66]-states[19])/algebraicVariables[65]; - algebraicVariables[68] = 1.0/(1.0+exp(-(algebraicVariables[8]-constants[79]-computedConstants[20])/(constants[78]*(1.0+computedConstants[21]/100.0)))); algebraicVariables[73] = (algebraicVariables[8] == -1.8)?-1.80001:algebraicVariables[8]; algebraicVariables[69] = 0.01143*(algebraicVariables[73]+1.8)/(exp((algebraicVariables[73]+1.8)/2.5)-1.0); algebraicVariables[72] = (algebraicVariables[8] == -41.8)?-41.80001:(algebraicVariables[8] == 0.0)?0.0:(algebraicVariables[8] == -6.8)?-6.80001:algebraicVariables[8]; - algebraicVariables[70] = -0.02839*(algebraicVariables[72]+41.8)/(exp(-(algebraicVariables[72]+41.8)/2.5)-1.0)-0.0849*(algebraicVariables[72]+6.8)/(exp(-(algebraicVariables[72]+6.8)/4.8)-1.0); + algebraicVariables[70] = -0.02839*(algebraicVariables[72]+41.8)/(exp((-algebraicVariables[72]-41.8)/2.5)-1.0)-0.0849*(algebraicVariables[72]+6.8)/(exp((-algebraicVariables[72]-6.8)/4.8)-1.0); algebraicVariables[71] = 0.001/(algebraicVariables[70]+algebraicVariables[69]); + algebraicVariables[68] = 1.0/(1.0+exp((-algebraicVariables[8]+constants[79]+computedConstants[20])/(constants[78]*(1.0+computedConstants[21]/100.0)))); rates[23] = (algebraicVariables[68]-states[23])/algebraicVariables[71]; algebraicVariables[75] = 0.001*(44.3+230.0*exp(-pow((algebraicVariables[8]+36.0)/10.0, 2.0))); algebraicVariables[74] = 1.0/(1.0+exp((algebraicVariables[8]+37.4+constants[81])/(5.3+constants[80]))); @@ -585,30 +585,30 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraicVariables[76] = constants[82]/(constants[82]+states[0]); algebraicVariables[77] = 0.001*algebraicVariables[76]/constants[83]; rates[21] = (algebraicVariables[76]-states[21])/algebraicVariables[77]; - algebraicVariables[79] = 0.001/(1.068*exp((algebraicVariables[8]+38.3)/30.0)+1.068*exp(-(algebraicVariables[8]+38.3)/30.0)); - algebraicVariables[78] = 1.0/(1.0+exp(-(algebraicVariables[8]+38.3)/5.5)); + algebraicVariables[79] = 0.001/(1.068*exp((algebraicVariables[8]+38.3)/30.0)+1.068*exp((-algebraicVariables[8]-38.3)/30.0)); + algebraicVariables[78] = 1.0/(1.0+exp((-algebraicVariables[8]-38.3)/5.5)); rates[25] = (algebraicVariables[78]-states[25])/algebraicVariables[79]; - algebraicVariables[81] = 1.0/(16.67*exp(-(algebraicVariables[8]+75.0)/83.3)+16.67*exp((algebraicVariables[8]+75.0)/15.38))+constants[85]; + algebraicVariables[81] = 1.0/(16.67*exp((-algebraicVariables[8]-75.0)/83.3)+16.67*exp((algebraicVariables[8]+75.0)/15.38))+constants[85]; algebraicVariables[80] = 1.0/(1.0+exp((algebraicVariables[8]+58.7)/3.8)); rates[24] = (algebraicVariables[80]-states[24])/algebraicVariables[81]; algebraicVariables[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraicVariables[8]+44.0))+0.065*exp(0.1*(algebraicVariables[8]+45.93)))+10.1); algebraicVariables[82] = 1.0/(1.0+exp((algebraicVariables[8]+49.0)/13.0)); rates[27] = (algebraicVariables[82]-states[27])/algebraicVariables[83]; algebraicVariables[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraicVariables[8]+30.61))+0.369*exp(-0.12*(algebraicVariables[8]+23.84)))+2.98); - algebraicVariables[84] = 1.0/(1.0+exp(-(algebraicVariables[8]-19.3)/15.0)); + algebraicVariables[84] = 1.0/(1.0+exp((-algebraicVariables[8]+19.3)/15.0)); rates[26] = (algebraicVariables[84]-states[26])/algebraicVariables[85]; algebraicVariables[89] = 0.84655354/(4.2*exp(algebraicVariables[8]/17.0)+0.15*exp(-algebraicVariables[8]/21.6)); - algebraicVariables[88] = 1.0/(1.0+exp(-(algebraicVariables[8]+10.0144)/7.6607)); + algebraicVariables[88] = 1.0/(1.0+exp((-algebraicVariables[8]-10.0144)/7.6607)); rates[29] = (algebraicVariables[88]-states[29])/algebraicVariables[89]; algebraicVariables[90] = 1.0/(30.0*exp(algebraicVariables[8]/10.0)+exp(-algebraicVariables[8]/12.0)); rates[30] = (algebraicVariables[88]-states[30])/algebraicVariables[90]; algebraicVariables[91] = 1.0/(100.0*exp(-algebraicVariables[8]/54.645)+656.0*exp(algebraicVariables[8]/106.157)); algebraicVariables[92] = 1.0/(1.0+exp((algebraicVariables[8]+28.6)/17.1)); rates[28] = (algebraicVariables[92]-states[28])/algebraicVariables[91]; - algebraicVariables[94] = sqrt(1.0/(1.0+exp(-(algebraicVariables[8]+0.6383-computedConstants[23])/10.7071))); - algebraicVariables[95] = 1.0*exp(-(algebraicVariables[8]-computedConstants[23]-5.0)/25.0); - algebraicVariables[96] = 28.0/(1.0+exp(-(algebraicVariables[8]-40.0-computedConstants[23])/3.0)); + algebraicVariables[95] = exp((-algebraicVariables[8]+computedConstants[23]+5.0)/25.0); + algebraicVariables[96] = 28.0/(1.0+exp((-algebraicVariables[8]+40.0+computedConstants[23])/3.0)); algebraicVariables[97] = 1.0/(algebraicVariables[96]+algebraicVariables[95]); + algebraicVariables[94] = sqrt(1.0/(1.0+exp((-algebraicVariables[8]-0.6383+computedConstants[23])/10.7071))); rates[31] = (algebraicVariables[94]-states[31])/algebraicVariables[97]; algebraicVariables[98] = 10.0*exp(0.0133*(algebraicVariables[8]+40.0)); algebraicVariables[100] = 1.0/(computedConstants[24]+algebraicVariables[98]); @@ -622,17 +622,17 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraicVariables[1] = computedConstants[0]*log(constants[2]/algebraicVariables[0]); algebraicVariables[2] = 0.5*computedConstants[0]*log(constants[5]/states[0]); algebraicVariables[8] = (constants[63] >= 1.0)?algebraicVariables[47]:states[15]; - algebraicVariables[4] = computedConstants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraicVariables[0], 1.3), -1.0)*pow(1.0+exp(-(algebraicVariables[8]-algebraicVariables[1]+110.0)/20.0), -1.0); - algebraicVariables[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraicVariables[8]/computedConstants[0])+algebraicVariables[0]/constants[19])+algebraicVariables[0]/constants[18]*(1.0+algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])); - algebraicVariables[13] = states[0]/constants[15]*exp(-constants[14]*algebraicVariables[8]/computedConstants[0])/algebraicVariables[20]; + algebraicVariables[4] = computedConstants[4]*constants[10]*1.0/(1.0+exp((-algebraicVariables[8]+algebraicVariables[1]-110.0)/20.0))/(1.0+pow(constants[8]/algebraicVariables[0], 1.3))/(1.0+pow(constants[9]/constants[4], 1.2)); + algebraicVariables[17] = exp(constants[16]*algebraicVariables[8]/(2.0*computedConstants[0])); algebraicVariables[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraicVariables[8]/computedConstants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])); algebraicVariables[14] = constants[5]/constants[22]*exp(constants[21]*algebraicVariables[8]/computedConstants[0])/algebraicVariables[21]; - algebraicVariables[17] = exp(constants[16]*algebraicVariables[8]/(2.0*computedConstants[0])); + algebraicVariables[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraicVariables[8]/computedConstants[0])+algebraicVariables[0]/constants[19])+algebraicVariables[0]/constants[18]*(1.0+algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])); algebraicVariables[19] = algebraicVariables[0]/constants[18]*algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])*exp(constants[16]*algebraicVariables[8]/(2.0*computedConstants[0]))/algebraicVariables[20]; + algebraicVariables[13] = states[0]/constants[15]*exp(-constants[14]*algebraicVariables[8]/computedConstants[0])/algebraicVariables[20]; algebraicVariables[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraicVariables[8]/(2.0*computedConstants[0]))/algebraicVariables[21]; algebraicVariables[9] = algebraicVariables[18]*computedConstants[5]*(algebraicVariables[19]+algebraicVariables[13])+algebraicVariables[19]*algebraicVariables[14]*(computedConstants[5]+algebraicVariables[17]); - algebraicVariables[16] = algebraicVariables[0]/(constants[13]+algebraicVariables[0]); algebraicVariables[15] = exp(-constants[16]*algebraicVariables[8]/(2.0*computedConstants[0])); + algebraicVariables[16] = algebraicVariables[0]/(constants[13]+algebraicVariables[0]); algebraicVariables[10] = algebraicVariables[19]*algebraicVariables[16]*(algebraicVariables[18]+algebraicVariables[14])+algebraicVariables[13]*algebraicVariables[18]*(algebraicVariables[16]+algebraicVariables[15]); algebraicVariables[11] = algebraicVariables[17]*algebraicVariables[16]*(algebraicVariables[19]+algebraicVariables[13])+algebraicVariables[15]*algebraicVariables[13]*(computedConstants[5]+algebraicVariables[17]); algebraicVariables[12] = algebraicVariables[15]*computedConstants[5]*(algebraicVariables[18]+algebraicVariables[14])+algebraicVariables[14]*algebraicVariables[17]*(algebraicVariables[16]+algebraicVariables[15]); @@ -654,11 +654,11 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraicVariables[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14]; algebraicVariables[39] = constants[76]*states[20]*states[19]*(algebraicVariables[8]-computedConstants[1]); algebraicVariables[40] = (constants[0] > 0.0)?constants[90]*constants[89]*(algebraicVariables[8]-computedConstants[1])*(1.0+exp((algebraicVariables[8]+20.0)/20.0))*states[32]:0.0; - algebraicVariables[37] = 2.0*constants[84]*algebraicVariables[8]/(computedConstants[0]*(1.0-exp(-1.0*algebraicVariables[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraicVariables[8]/computedConstants[0]))*states[25]*states[24]; - algebraicVariables[5] = 0.0000185*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0])))*(algebraicVariables[0]-constants[2]*exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraicVariables[67] = 0.000365*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraicVariables[38] = 2.0*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraicVariables[41] = (algebraicVariables[38]+algebraicVariables[67]+algebraicVariables[5])*(1.0-computedConstants[19])*1.0*computedConstants[18]; + algebraicVariables[37] = 2.0*constants[84]*algebraicVariables[8]/(computedConstants[0]*(1.0-exp(-algebraicVariables[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraicVariables[8]/computedConstants[0]))*states[25]*states[24]; + algebraicVariables[5] = 0.0000185*constants[77]*algebraicVariables[8]/(computedConstants[0]*(1.0-exp(-algebraicVariables[8]/computedConstants[0])))*(algebraicVariables[0]-constants[2]*exp(-algebraicVariables[8]/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraicVariables[67] = 0.000365*constants[77]*algebraicVariables[8]/(computedConstants[0]*(1.0-exp(-algebraicVariables[8]/computedConstants[0])))*(constants[3]-constants[4]*exp(-algebraicVariables[8]/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraicVariables[38] = 2.0*constants[77]*algebraicVariables[8]/(computedConstants[0]*(1.0-exp(-algebraicVariables[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraicVariables[8]/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraicVariables[41] = (algebraicVariables[38]+algebraicVariables[67]+algebraicVariables[5])*(1.0-computedConstants[19])*computedConstants[18]; algebraicVariables[51] = computedConstants[0]*log((constants[2]+0.12*constants[4])/(algebraicVariables[0]+0.12*constants[3])); algebraicVariables[53] = constants[74]*pow(states[18], 3.0)*(algebraicVariables[8]-algebraicVariables[51]); algebraicVariables[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraicVariables[8]-algebraicVariables[51]); @@ -672,8 +672,8 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraicVariables[45] = algebraicVariables[6]+algebraicVariables[48]; algebraicVariables[46] = algebraicVariables[45]+algebraicVariables[44]+algebraicVariables[43]+algebraicVariables[42]+algebraicVariables[4]+algebraicVariables[3]+algebraicVariables[7]+algebraicVariables[41]+algebraicVariables[37]+algebraicVariables[40]+algebraicVariables[39]; algebraicVariables[49] = 1.0/(0.36*(algebraicVariables[8]+148.8-computedConstants[16]-computedConstants[17])/(exp(0.066*(algebraicVariables[8]+148.8-computedConstants[16]-computedConstants[17]))-1.0)+0.1*(algebraicVariables[8]+87.3-computedConstants[16]-computedConstants[17])/(1.0-exp(-0.2*(algebraicVariables[8]+87.3-computedConstants[16]-computedConstants[17]))))-0.054; - algebraicVariables[50] = (algebraicVariables[8] < -(80.0-computedConstants[16]-computedConstants[17]-constants[72]))?0.01329+0.99921/(1.0+exp((algebraicVariables[8]+97.134-computedConstants[16]-computedConstants[17]-constants[72])/8.1752)):0.0002501*exp(-(algebraicVariables[8]-computedConstants[16]-computedConstants[17]-constants[72])/12.861); - algebraicVariables[54] = 1.0/(1.0+exp(-(algebraicVariables[8]+42.0504)/8.3106)); + algebraicVariables[50] = (algebraicVariables[8] < -80.0+computedConstants[16]+computedConstants[17]+constants[72])?0.01329+0.99921/(1.0+exp((algebraicVariables[8]+97.134-computedConstants[16]-computedConstants[17]-constants[72])/8.1752)):0.0002501*exp((-algebraicVariables[8]+computedConstants[16]+computedConstants[17]+constants[72])/12.861); + algebraicVariables[54] = 1.0/(1.0+exp((-algebraicVariables[8]-42.0504)/8.3106)); algebraicVariables[55] = algebraicVariables[8]+41.0; algebraicVariables[56] = (fabs(algebraicVariables[55]) < constants[75])?2000.0:200.0*algebraicVariables[55]/(1.0-exp(-0.1*algebraicVariables[55])); algebraicVariables[57] = 8000.0*exp(-0.056*(algebraicVariables[8]+66.0)); @@ -686,34 +686,34 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraicVariables[63] = 0.009/(1.0+exp((algebraicVariables[8]+5.0)/12.0))+0.0005; algebraicVariables[66] = 1.0/(1.0+exp((algebraicVariables[8]+7.5)/10.0)); algebraicVariables[65] = 0.59/(1.0+exp((algebraicVariables[8]+60.0)/10.0))+3.05; - algebraicVariables[68] = 1.0/(1.0+exp(-(algebraicVariables[8]-constants[79]-computedConstants[20])/(constants[78]*(1.0+computedConstants[21]/100.0)))); + algebraicVariables[68] = 1.0/(1.0+exp((-algebraicVariables[8]+constants[79]+computedConstants[20])/(constants[78]*(1.0+computedConstants[21]/100.0)))); algebraicVariables[73] = (algebraicVariables[8] == -1.8)?-1.80001:algebraicVariables[8]; algebraicVariables[69] = 0.01143*(algebraicVariables[73]+1.8)/(exp((algebraicVariables[73]+1.8)/2.5)-1.0); algebraicVariables[72] = (algebraicVariables[8] == -41.8)?-41.80001:(algebraicVariables[8] == 0.0)?0.0:(algebraicVariables[8] == -6.8)?-6.80001:algebraicVariables[8]; - algebraicVariables[70] = -0.02839*(algebraicVariables[72]+41.8)/(exp(-(algebraicVariables[72]+41.8)/2.5)-1.0)-0.0849*(algebraicVariables[72]+6.8)/(exp(-(algebraicVariables[72]+6.8)/4.8)-1.0); + algebraicVariables[70] = -0.02839*(algebraicVariables[72]+41.8)/(exp((-algebraicVariables[72]-41.8)/2.5)-1.0)-0.0849*(algebraicVariables[72]+6.8)/(exp((-algebraicVariables[72]-6.8)/4.8)-1.0); algebraicVariables[71] = 0.001/(algebraicVariables[70]+algebraicVariables[69]); algebraicVariables[74] = 1.0/(1.0+exp((algebraicVariables[8]+37.4+constants[81])/(5.3+constants[80]))); algebraicVariables[75] = 0.001*(44.3+230.0*exp(-pow((algebraicVariables[8]+36.0)/10.0, 2.0))); algebraicVariables[76] = constants[82]/(constants[82]+states[0]); algebraicVariables[77] = 0.001*algebraicVariables[76]/constants[83]; - algebraicVariables[78] = 1.0/(1.0+exp(-(algebraicVariables[8]+38.3)/5.5)); - algebraicVariables[79] = 0.001/(1.068*exp((algebraicVariables[8]+38.3)/30.0)+1.068*exp(-(algebraicVariables[8]+38.3)/30.0)); + algebraicVariables[78] = 1.0/(1.0+exp((-algebraicVariables[8]-38.3)/5.5)); + algebraicVariables[79] = 0.001/(1.068*exp((algebraicVariables[8]+38.3)/30.0)+1.068*exp((-algebraicVariables[8]-38.3)/30.0)); algebraicVariables[80] = 1.0/(1.0+exp((algebraicVariables[8]+58.7)/3.8)); - algebraicVariables[81] = 1.0/(16.67*exp(-(algebraicVariables[8]+75.0)/83.3)+16.67*exp((algebraicVariables[8]+75.0)/15.38))+constants[85]; + algebraicVariables[81] = 1.0/(16.67*exp((-algebraicVariables[8]-75.0)/83.3)+16.67*exp((algebraicVariables[8]+75.0)/15.38))+constants[85]; algebraicVariables[82] = 1.0/(1.0+exp((algebraicVariables[8]+49.0)/13.0)); algebraicVariables[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraicVariables[8]+44.0))+0.065*exp(0.1*(algebraicVariables[8]+45.93)))+10.1); - algebraicVariables[84] = 1.0/(1.0+exp(-(algebraicVariables[8]-19.3)/15.0)); + algebraicVariables[84] = 1.0/(1.0+exp((-algebraicVariables[8]+19.3)/15.0)); algebraicVariables[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraicVariables[8]+30.61))+0.369*exp(-0.12*(algebraicVariables[8]+23.84)))+2.98); - algebraicVariables[86] = 1.0/(1.0+exp(-(algebraicVariables[8]+23.2)/6.6))/(0.84655354/(37.2*exp(algebraicVariables[8]/11.9)+0.96*exp(-algebraicVariables[8]/18.5))); - algebraicVariables[87] = 4.0*((37.2*exp(algebraicVariables[8]/15.9)+0.96*exp(-algebraicVariables[8]/22.5))/0.84655354-1.0/(1.0+exp(-(algebraicVariables[8]+23.2)/10.6))/(0.84655354/(37.2*exp(algebraicVariables[8]/15.9)+0.96*exp(-algebraicVariables[8]/22.5)))); - algebraicVariables[88] = 1.0/(1.0+exp(-(algebraicVariables[8]+10.0144)/7.6607)); + algebraicVariables[86] = 1.0/(1.0+exp((-algebraicVariables[8]-23.2)/6.6))/(0.84655354/(37.2*exp(algebraicVariables[8]/11.9)+0.96*exp(-algebraicVariables[8]/18.5))); + algebraicVariables[87] = 4.0*((37.2*exp(algebraicVariables[8]/15.9)+0.96*exp(-algebraicVariables[8]/22.5))/0.84655354-1.0/(1.0+exp((-algebraicVariables[8]-23.2)/10.6))/(0.84655354/(37.2*exp(algebraicVariables[8]/15.9)+0.96*exp(-algebraicVariables[8]/22.5)))); + algebraicVariables[88] = 1.0/(1.0+exp((-algebraicVariables[8]-10.0144)/7.6607)); algebraicVariables[89] = 0.84655354/(4.2*exp(algebraicVariables[8]/17.0)+0.15*exp(-algebraicVariables[8]/21.6)); algebraicVariables[90] = 1.0/(30.0*exp(algebraicVariables[8]/10.0)+exp(-algebraicVariables[8]/12.0)); algebraicVariables[91] = 1.0/(100.0*exp(-algebraicVariables[8]/54.645)+656.0*exp(algebraicVariables[8]/106.157)); algebraicVariables[92] = 1.0/(1.0+exp((algebraicVariables[8]+28.6)/17.1)); - algebraicVariables[94] = sqrt(1.0/(1.0+exp(-(algebraicVariables[8]+0.6383-computedConstants[23])/10.7071))); - algebraicVariables[95] = 1.0*exp(-(algebraicVariables[8]-computedConstants[23]-5.0)/25.0); - algebraicVariables[96] = 28.0/(1.0+exp(-(algebraicVariables[8]-40.0-computedConstants[23])/3.0)); + algebraicVariables[94] = sqrt(1.0/(1.0+exp((-algebraicVariables[8]-0.6383+computedConstants[23])/10.7071))); + algebraicVariables[95] = exp((-algebraicVariables[8]+computedConstants[23]+5.0)/25.0); + algebraicVariables[96] = 28.0/(1.0+exp((-algebraicVariables[8]+40.0+computedConstants[23])/3.0)); algebraicVariables[97] = 1.0/(algebraicVariables[96]+algebraicVariables[95]); algebraicVariables[98] = 10.0*exp(0.0133*(algebraicVariables[8]+40.0)); algebraicVariables[99] = computedConstants[24]/(computedConstants[24]+algebraicVariables[98]); 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 4dabc2c05f..112cd2ef57 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 @@ -457,7 +457,7 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants computed_constants[13] = constants[70]*computed_constants[12] computed_constants[14] = computed_constants[13]*constants[4]/(constants[4]+constants[68]) computed_constants[15] = computed_constants[12]*constants[4]/(constants[4]+constants[68]) - computed_constants[16] = -1.0-9.898*pow(1.0*constants[0], 0.618)/(pow(1.0*constants[0], 0.618)+0.00122423) if gt_func(constants[0], 0.0) else 0.0 + computed_constants[16] = -1.0-9.898*pow(constants[0], 0.618)/(pow(constants[0], 0.618)+0.00122423) if gt_func(constants[0], 0.0) else 0.0 computed_constants[17] = 7.5 if gt_func(constants[1], 0.0) else 0.0 computed_constants[18] = 1.23 if gt_func(constants[1], 0.0) else 1.0 computed_constants[19] = 0.31*constants[0]/(constants[0]+0.00009) @@ -465,36 +465,36 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants computed_constants[21] = -27.0 if gt_func(constants[1], 0.0) else 0.0 computed_constants[22] = 1.2*constants[88] if gt_func(constants[1], 0.0) else constants[88] computed_constants[23] = -14.0 if gt_func(constants[1], 0.0) else 0.0 - computed_constants[24] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*constants[0], 1.6951))+0.025641 + computed_constants[24] = 3.573159/(1.0+0.0000012155/pow(constants[0], 1.6951))+0.025641 def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - algebraic_variables[0] = states[1] algebraic_variables[47] = constants[64] if and_func(gt_func(voi, constants[66]), lt_func(voi, constants[66]+constants[65])) else constants[67] algebraic_variables[8] = algebraic_variables[47] if geq_func(constants[63], 1.0) else states[15] - algebraic_variables[5] = 0.0000185*constants[77]*(algebraic_variables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic_variables[8]-0.0)/computed_constants[0])))*(algebraic_variables[0]-constants[2]*exp(-1.0*(algebraic_variables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic_variables[1] = computed_constants[0]*log(constants[2]/algebraic_variables[0]) - algebraic_variables[6] = states[16]*computed_constants[14]*(algebraic_variables[8]-algebraic_variables[1])*(1.0-constants[71]) - algebraic_variables[51] = computed_constants[0]*log((constants[2]+0.12*constants[4])/(algebraic_variables[0]+0.12*constants[3])) - algebraic_variables[53] = constants[74]*pow(states[18], 3.0)*(algebraic_variables[8]-algebraic_variables[51]) - algebraic_variables[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic_variables[8]-algebraic_variables[51]) - algebraic_variables[7] = algebraic_variables[52]+algebraic_variables[53] - algebraic_variables[4] = computed_constants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic_variables[0], 1.3), -1.0)*pow(1.0+exp(-(algebraic_variables[8]-algebraic_variables[1]+110.0)/20.0), -1.0) - algebraic_variables[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraic_variables[8]/computed_constants[0])+algebraic_variables[0]/constants[19])+algebraic_variables[0]/constants[18]*(1.0+algebraic_variables[0]/constants[17]*(1.0+algebraic_variables[0]/constants[13])) - algebraic_variables[13] = states[0]/constants[15]*exp(-constants[14]*algebraic_variables[8]/computed_constants[0])/algebraic_variables[20] + algebraic_variables[17] = exp(constants[16]*algebraic_variables[8]/(2.0*computed_constants[0])) algebraic_variables[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraic_variables[8]/computed_constants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])) algebraic_variables[14] = constants[5]/constants[22]*exp(constants[21]*algebraic_variables[8]/computed_constants[0])/algebraic_variables[21] - algebraic_variables[17] = exp(constants[16]*algebraic_variables[8]/(2.0*computed_constants[0])) + algebraic_variables[0] = states[1] + algebraic_variables[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraic_variables[8]/computed_constants[0])+algebraic_variables[0]/constants[19])+algebraic_variables[0]/constants[18]*(1.0+algebraic_variables[0]/constants[17]*(1.0+algebraic_variables[0]/constants[13])) algebraic_variables[19] = algebraic_variables[0]/constants[18]*algebraic_variables[0]/constants[17]*(1.0+algebraic_variables[0]/constants[13])*exp(constants[16]*algebraic_variables[8]/(2.0*computed_constants[0]))/algebraic_variables[20] + algebraic_variables[13] = states[0]/constants[15]*exp(-constants[14]*algebraic_variables[8]/computed_constants[0])/algebraic_variables[20] algebraic_variables[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraic_variables[8]/(2.0*computed_constants[0]))/algebraic_variables[21] algebraic_variables[9] = algebraic_variables[18]*computed_constants[5]*(algebraic_variables[19]+algebraic_variables[13])+algebraic_variables[19]*algebraic_variables[14]*(computed_constants[5]+algebraic_variables[17]) - algebraic_variables[16] = algebraic_variables[0]/(constants[13]+algebraic_variables[0]) algebraic_variables[15] = exp(-constants[16]*algebraic_variables[8]/(2.0*computed_constants[0])) + algebraic_variables[16] = algebraic_variables[0]/(constants[13]+algebraic_variables[0]) algebraic_variables[10] = algebraic_variables[19]*algebraic_variables[16]*(algebraic_variables[18]+algebraic_variables[14])+algebraic_variables[13]*algebraic_variables[18]*(algebraic_variables[16]+algebraic_variables[15]) algebraic_variables[11] = algebraic_variables[17]*algebraic_variables[16]*(algebraic_variables[19]+algebraic_variables[13])+algebraic_variables[15]*algebraic_variables[13]*(computed_constants[5]+algebraic_variables[17]) algebraic_variables[12] = algebraic_variables[15]*computed_constants[5]*(algebraic_variables[18]+algebraic_variables[14])+algebraic_variables[14]*algebraic_variables[17]*(algebraic_variables[16]+algebraic_variables[15]) algebraic_variables[3] = (1.0-constants[12])*constants[11]*(algebraic_variables[11]*algebraic_variables[14]-algebraic_variables[12]*algebraic_variables[13])/(algebraic_variables[12]+algebraic_variables[11]+algebraic_variables[10]+algebraic_variables[9]) - rates[1] = (1.0-constants[7])*-1.0*(algebraic_variables[7]+algebraic_variables[6]+algebraic_variables[5]+3.0*algebraic_variables[4]+3.0*algebraic_variables[3])/(1.0*(computed_constants[3]+computed_constants[2])*constants[6]) + algebraic_variables[1] = computed_constants[0]*log(constants[2]/algebraic_variables[0]) + algebraic_variables[4] = computed_constants[4]*constants[10]*1.0/(1.0+exp((-algebraic_variables[8]+algebraic_variables[1]-110.0)/20.0))/(1.0+pow(constants[8]/algebraic_variables[0], 1.3))/(1.0+pow(constants[9]/constants[4], 1.2)) + algebraic_variables[5] = 0.0000185*constants[77]*algebraic_variables[8]/(computed_constants[0]*(1.0-exp(-algebraic_variables[8]/computed_constants[0])))*(algebraic_variables[0]-constants[2]*exp(-algebraic_variables[8]/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic_variables[6] = states[16]*computed_constants[14]*(algebraic_variables[8]-algebraic_variables[1])*(1.0-constants[71]) + algebraic_variables[51] = computed_constants[0]*log((constants[2]+0.12*constants[4])/(algebraic_variables[0]+0.12*constants[3])) + algebraic_variables[53] = constants[74]*pow(states[18], 3.0)*(algebraic_variables[8]-algebraic_variables[51]) + algebraic_variables[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic_variables[8]-algebraic_variables[51]) + algebraic_variables[7] = algebraic_variables[52]+algebraic_variables[53] + rates[1] = (1.0-constants[7])*(-algebraic_variables[7]-algebraic_variables[6]-algebraic_variables[5]-3.0*algebraic_variables[4]-3.0*algebraic_variables[3])/((computed_constants[3]+computed_constants[2])*constants[6]) algebraic_variables[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])) algebraic_variables[25] = constants[30]/algebraic_variables[24] algebraic_variables[26] = constants[31]*algebraic_variables[24] @@ -516,18 +516,18 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v rates[14] = algebraic_variables[36] algebraic_variables[29] = computed_constants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])) algebraic_variables[28] = (states[0]-states[7])/constants[35] - rates[7] = 1.0*(algebraic_variables[28]*computed_constants[2]-algebraic_variables[29]*computed_constants[8])/computed_constants[3]-(constants[52]*algebraic_variables[34]+constants[50]*algebraic_variables[31]+constants[51]*algebraic_variables[32]) + rates[7] = (algebraic_variables[28]*computed_constants[2]-algebraic_variables[29]*computed_constants[8])/computed_constants[3]-(constants[52]*algebraic_variables[34]+constants[50]*algebraic_variables[31]+constants[51]*algebraic_variables[32]) + algebraic_variables[37] = 2.0*constants[84]*algebraic_variables[8]/(computed_constants[0]*(1.0-exp(-algebraic_variables[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic_variables[8]/computed_constants[0]))*states[25]*states[24] + algebraic_variables[38] = 2.0*constants[77]*algebraic_variables[8]/(computed_constants[0]*(1.0-exp(-algebraic_variables[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic_variables[8]/computed_constants[0]))*states[23]*states[22]*states[21] algebraic_variables[22] = constants[25]*states[3]*(states[2]-states[0]) - algebraic_variables[37] = 2.0*constants[84]*algebraic_variables[8]/(computed_constants[0]*(1.0-exp(-1.0*algebraic_variables[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic_variables[8]/computed_constants[0]))*states[25]*states[24] - algebraic_variables[38] = 2.0*constants[77]*(algebraic_variables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic_variables[8]-0.0)*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic_variables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] rates[0] = algebraic_variables[22]*computed_constants[9]/computed_constants[2]-((algebraic_variables[38]+algebraic_variables[37]-2.0*algebraic_variables[3])/(2.0*constants[6]*computed_constants[2])+algebraic_variables[28]+constants[52]*algebraic_variables[35]) algebraic_variables[30] = (states[8]-states[2])/constants[38] rates[8] = algebraic_variables[29]-algebraic_variables[30]*computed_constants[9]/computed_constants[8] rates[2] = algebraic_variables[30]-(algebraic_variables[22]+constants[53]*algebraic_variables[36]) algebraic_variables[39] = constants[76]*states[20]*states[19]*(algebraic_variables[8]-computed_constants[1]) algebraic_variables[40] = constants[90]*constants[89]*(algebraic_variables[8]-computed_constants[1])*(1.0+exp((algebraic_variables[8]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 - algebraic_variables[67] = 0.000365*constants[77]*(algebraic_variables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic_variables[8]-0.0)/computed_constants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraic_variables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic_variables[41] = (algebraic_variables[38]+algebraic_variables[67]+algebraic_variables[5])*(1.0-computed_constants[19])*1.0*computed_constants[18] + algebraic_variables[67] = 0.000365*constants[77]*algebraic_variables[8]/(computed_constants[0]*(1.0-exp(-algebraic_variables[8]/computed_constants[0])))*(constants[3]-constants[4]*exp(-algebraic_variables[8]/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic_variables[41] = (algebraic_variables[38]+algebraic_variables[67]+algebraic_variables[5])*(1.0-computed_constants[19])*computed_constants[18] algebraic_variables[42] = constants[86]*(algebraic_variables[8]-computed_constants[1])*states[27]*states[26] algebraic_variables[93] = computed_constants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraic_variables[0])) algebraic_variables[43] = computed_constants[22]*(algebraic_variables[8]-algebraic_variables[93])*pow(states[31], 2.0) @@ -537,13 +537,13 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v algebraic_variables[46] = algebraic_variables[45]+algebraic_variables[44]+algebraic_variables[43]+algebraic_variables[42]+algebraic_variables[4]+algebraic_variables[3]+algebraic_variables[7]+algebraic_variables[41]+algebraic_variables[37]+algebraic_variables[40]+algebraic_variables[39] rates[15] = -algebraic_variables[46]/constants[60] algebraic_variables[49] = 1.0/(0.36*(algebraic_variables[8]+148.8-computed_constants[16]-computed_constants[17])/(exp(0.066*(algebraic_variables[8]+148.8-computed_constants[16]-computed_constants[17]))-1.0)+0.1*(algebraic_variables[8]+87.3-computed_constants[16]-computed_constants[17])/(1.0-exp(-0.2*(algebraic_variables[8]+87.3-computed_constants[16]-computed_constants[17]))))-0.054 - algebraic_variables[50] = 0.01329+0.99921/(1.0+exp((algebraic_variables[8]+97.134-computed_constants[16]-computed_constants[17]-constants[72])/8.1752)) if lt_func(algebraic_variables[8], -(80.0-computed_constants[16]-computed_constants[17]-constants[72])) else 0.0002501*exp(-(algebraic_variables[8]-computed_constants[16]-computed_constants[17]-constants[72])/12.861) + algebraic_variables[50] = 0.01329+0.99921/(1.0+exp((algebraic_variables[8]+97.134-computed_constants[16]-computed_constants[17]-constants[72])/8.1752)) if lt_func(algebraic_variables[8], -80.0+computed_constants[16]+computed_constants[17]+constants[72]) else 0.0002501*exp((-algebraic_variables[8]+computed_constants[16]+computed_constants[17]+constants[72])/12.861) rates[16] = (algebraic_variables[50]-states[16])/algebraic_variables[49] algebraic_variables[57] = 8000.0*exp(-0.056*(algebraic_variables[8]+66.0)) algebraic_variables[55] = algebraic_variables[8]+41.0 algebraic_variables[56] = 2000.0 if lt_func(fabs(algebraic_variables[55]), constants[75]) else 200.0*algebraic_variables[55]/(1.0-exp(-0.1*algebraic_variables[55])) algebraic_variables[58] = 1.0/(algebraic_variables[56]+algebraic_variables[57]) - algebraic_variables[54] = 1.0/(1.0+exp(-(algebraic_variables[8]+42.0504)/8.3106)) + algebraic_variables[54] = 1.0/(1.0+exp((-algebraic_variables[8]-42.0504)/8.3106)) rates[18] = (algebraic_variables[54]-states[18])/algebraic_variables[58] algebraic_variables[61] = 2000.0/(320.0*exp(-0.1*(algebraic_variables[8]+75.0))+1.0) algebraic_variables[60] = 20.0*exp(-0.125*(algebraic_variables[8]+75.0)) @@ -556,12 +556,12 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v algebraic_variables[65] = 0.59/(1.0+exp((algebraic_variables[8]+60.0)/10.0))+3.05 algebraic_variables[66] = 1.0/(1.0+exp((algebraic_variables[8]+7.5)/10.0)) rates[19] = (algebraic_variables[66]-states[19])/algebraic_variables[65] - algebraic_variables[68] = 1.0/(1.0+exp(-(algebraic_variables[8]-constants[79]-computed_constants[20])/(constants[78]*(1.0+computed_constants[21]/100.0)))) algebraic_variables[73] = -1.80001 if eq_func(algebraic_variables[8], -1.8) else algebraic_variables[8] algebraic_variables[69] = 0.01143*(algebraic_variables[73]+1.8)/(exp((algebraic_variables[73]+1.8)/2.5)-1.0) algebraic_variables[72] = -41.80001 if eq_func(algebraic_variables[8], -41.8) else 0.0 if eq_func(algebraic_variables[8], 0.0) else -6.80001 if eq_func(algebraic_variables[8], -6.8) else algebraic_variables[8] - algebraic_variables[70] = -0.02839*(algebraic_variables[72]+41.8)/(exp(-(algebraic_variables[72]+41.8)/2.5)-1.0)-0.0849*(algebraic_variables[72]+6.8)/(exp(-(algebraic_variables[72]+6.8)/4.8)-1.0) + algebraic_variables[70] = -0.02839*(algebraic_variables[72]+41.8)/(exp((-algebraic_variables[72]-41.8)/2.5)-1.0)-0.0849*(algebraic_variables[72]+6.8)/(exp((-algebraic_variables[72]-6.8)/4.8)-1.0) algebraic_variables[71] = 0.001/(algebraic_variables[70]+algebraic_variables[69]) + algebraic_variables[68] = 1.0/(1.0+exp((-algebraic_variables[8]+constants[79]+computed_constants[20])/(constants[78]*(1.0+computed_constants[21]/100.0)))) rates[23] = (algebraic_variables[68]-states[23])/algebraic_variables[71] algebraic_variables[75] = 0.001*(44.3+230.0*exp(-pow((algebraic_variables[8]+36.0)/10.0, 2.0))) algebraic_variables[74] = 1.0/(1.0+exp((algebraic_variables[8]+37.4+constants[81])/(5.3+constants[80]))) @@ -569,30 +569,30 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v algebraic_variables[76] = constants[82]/(constants[82]+states[0]) algebraic_variables[77] = 0.001*algebraic_variables[76]/constants[83] rates[21] = (algebraic_variables[76]-states[21])/algebraic_variables[77] - algebraic_variables[79] = 0.001/(1.068*exp((algebraic_variables[8]+38.3)/30.0)+1.068*exp(-(algebraic_variables[8]+38.3)/30.0)) - algebraic_variables[78] = 1.0/(1.0+exp(-(algebraic_variables[8]+38.3)/5.5)) + algebraic_variables[79] = 0.001/(1.068*exp((algebraic_variables[8]+38.3)/30.0)+1.068*exp((-algebraic_variables[8]-38.3)/30.0)) + algebraic_variables[78] = 1.0/(1.0+exp((-algebraic_variables[8]-38.3)/5.5)) rates[25] = (algebraic_variables[78]-states[25])/algebraic_variables[79] - algebraic_variables[81] = 1.0/(16.67*exp(-(algebraic_variables[8]+75.0)/83.3)+16.67*exp((algebraic_variables[8]+75.0)/15.38))+constants[85] + algebraic_variables[81] = 1.0/(16.67*exp((-algebraic_variables[8]-75.0)/83.3)+16.67*exp((algebraic_variables[8]+75.0)/15.38))+constants[85] algebraic_variables[80] = 1.0/(1.0+exp((algebraic_variables[8]+58.7)/3.8)) rates[24] = (algebraic_variables[80]-states[24])/algebraic_variables[81] algebraic_variables[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic_variables[8]+44.0))+0.065*exp(0.1*(algebraic_variables[8]+45.93)))+10.1) algebraic_variables[82] = 1.0/(1.0+exp((algebraic_variables[8]+49.0)/13.0)) rates[27] = (algebraic_variables[82]-states[27])/algebraic_variables[83] algebraic_variables[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic_variables[8]+30.61))+0.369*exp(-0.12*(algebraic_variables[8]+23.84)))+2.98) - algebraic_variables[84] = 1.0/(1.0+exp(-(algebraic_variables[8]-19.3)/15.0)) + algebraic_variables[84] = 1.0/(1.0+exp((-algebraic_variables[8]+19.3)/15.0)) rates[26] = (algebraic_variables[84]-states[26])/algebraic_variables[85] algebraic_variables[89] = 0.84655354/(4.2*exp(algebraic_variables[8]/17.0)+0.15*exp(-algebraic_variables[8]/21.6)) - algebraic_variables[88] = 1.0/(1.0+exp(-(algebraic_variables[8]+10.0144)/7.6607)) + algebraic_variables[88] = 1.0/(1.0+exp((-algebraic_variables[8]-10.0144)/7.6607)) rates[29] = (algebraic_variables[88]-states[29])/algebraic_variables[89] algebraic_variables[90] = 1.0/(30.0*exp(algebraic_variables[8]/10.0)+exp(-algebraic_variables[8]/12.0)) rates[30] = (algebraic_variables[88]-states[30])/algebraic_variables[90] algebraic_variables[91] = 1.0/(100.0*exp(-algebraic_variables[8]/54.645)+656.0*exp(algebraic_variables[8]/106.157)) algebraic_variables[92] = 1.0/(1.0+exp((algebraic_variables[8]+28.6)/17.1)) rates[28] = (algebraic_variables[92]-states[28])/algebraic_variables[91] - algebraic_variables[94] = sqrt(1.0/(1.0+exp(-(algebraic_variables[8]+0.6383-computed_constants[23])/10.7071))) - algebraic_variables[95] = 1.0*exp(-(algebraic_variables[8]-computed_constants[23]-5.0)/25.0) - algebraic_variables[96] = 28.0/(1.0+exp(-(algebraic_variables[8]-40.0-computed_constants[23])/3.0)) + algebraic_variables[95] = exp((-algebraic_variables[8]+computed_constants[23]+5.0)/25.0) + algebraic_variables[96] = 28.0/(1.0+exp((-algebraic_variables[8]+40.0+computed_constants[23])/3.0)) algebraic_variables[97] = 1.0/(algebraic_variables[96]+algebraic_variables[95]) + algebraic_variables[94] = sqrt(1.0/(1.0+exp((-algebraic_variables[8]-0.6383+computed_constants[23])/10.7071))) rates[31] = (algebraic_variables[94]-states[31])/algebraic_variables[97] algebraic_variables[98] = 10.0*exp(0.0133*(algebraic_variables[8]+40.0)) algebraic_variables[100] = 1.0/(computed_constants[24]+algebraic_variables[98]) @@ -605,17 +605,17 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic_variables[1] = computed_constants[0]*log(constants[2]/algebraic_variables[0]) algebraic_variables[2] = 0.5*computed_constants[0]*log(constants[5]/states[0]) algebraic_variables[8] = algebraic_variables[47] if geq_func(constants[63], 1.0) else states[15] - algebraic_variables[4] = computed_constants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic_variables[0], 1.3), -1.0)*pow(1.0+exp(-(algebraic_variables[8]-algebraic_variables[1]+110.0)/20.0), -1.0) - algebraic_variables[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraic_variables[8]/computed_constants[0])+algebraic_variables[0]/constants[19])+algebraic_variables[0]/constants[18]*(1.0+algebraic_variables[0]/constants[17]*(1.0+algebraic_variables[0]/constants[13])) - algebraic_variables[13] = states[0]/constants[15]*exp(-constants[14]*algebraic_variables[8]/computed_constants[0])/algebraic_variables[20] + algebraic_variables[4] = computed_constants[4]*constants[10]*1.0/(1.0+exp((-algebraic_variables[8]+algebraic_variables[1]-110.0)/20.0))/(1.0+pow(constants[8]/algebraic_variables[0], 1.3))/(1.0+pow(constants[9]/constants[4], 1.2)) + algebraic_variables[17] = exp(constants[16]*algebraic_variables[8]/(2.0*computed_constants[0])) algebraic_variables[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraic_variables[8]/computed_constants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])) algebraic_variables[14] = constants[5]/constants[22]*exp(constants[21]*algebraic_variables[8]/computed_constants[0])/algebraic_variables[21] - algebraic_variables[17] = exp(constants[16]*algebraic_variables[8]/(2.0*computed_constants[0])) + algebraic_variables[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraic_variables[8]/computed_constants[0])+algebraic_variables[0]/constants[19])+algebraic_variables[0]/constants[18]*(1.0+algebraic_variables[0]/constants[17]*(1.0+algebraic_variables[0]/constants[13])) algebraic_variables[19] = algebraic_variables[0]/constants[18]*algebraic_variables[0]/constants[17]*(1.0+algebraic_variables[0]/constants[13])*exp(constants[16]*algebraic_variables[8]/(2.0*computed_constants[0]))/algebraic_variables[20] + algebraic_variables[13] = states[0]/constants[15]*exp(-constants[14]*algebraic_variables[8]/computed_constants[0])/algebraic_variables[20] algebraic_variables[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraic_variables[8]/(2.0*computed_constants[0]))/algebraic_variables[21] algebraic_variables[9] = algebraic_variables[18]*computed_constants[5]*(algebraic_variables[19]+algebraic_variables[13])+algebraic_variables[19]*algebraic_variables[14]*(computed_constants[5]+algebraic_variables[17]) - algebraic_variables[16] = algebraic_variables[0]/(constants[13]+algebraic_variables[0]) algebraic_variables[15] = exp(-constants[16]*algebraic_variables[8]/(2.0*computed_constants[0])) + algebraic_variables[16] = algebraic_variables[0]/(constants[13]+algebraic_variables[0]) algebraic_variables[10] = algebraic_variables[19]*algebraic_variables[16]*(algebraic_variables[18]+algebraic_variables[14])+algebraic_variables[13]*algebraic_variables[18]*(algebraic_variables[16]+algebraic_variables[15]) algebraic_variables[11] = algebraic_variables[17]*algebraic_variables[16]*(algebraic_variables[19]+algebraic_variables[13])+algebraic_variables[15]*algebraic_variables[13]*(computed_constants[5]+algebraic_variables[17]) algebraic_variables[12] = algebraic_variables[15]*computed_constants[5]*(algebraic_variables[18]+algebraic_variables[14])+algebraic_variables[14]*algebraic_variables[17]*(algebraic_variables[16]+algebraic_variables[15]) @@ -637,11 +637,11 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic_variables[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14] algebraic_variables[39] = constants[76]*states[20]*states[19]*(algebraic_variables[8]-computed_constants[1]) algebraic_variables[40] = constants[90]*constants[89]*(algebraic_variables[8]-computed_constants[1])*(1.0+exp((algebraic_variables[8]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 - algebraic_variables[37] = 2.0*constants[84]*algebraic_variables[8]/(computed_constants[0]*(1.0-exp(-1.0*algebraic_variables[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic_variables[8]/computed_constants[0]))*states[25]*states[24] - algebraic_variables[5] = 0.0000185*constants[77]*(algebraic_variables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic_variables[8]-0.0)/computed_constants[0])))*(algebraic_variables[0]-constants[2]*exp(-1.0*(algebraic_variables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic_variables[67] = 0.000365*constants[77]*(algebraic_variables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic_variables[8]-0.0)/computed_constants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraic_variables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic_variables[38] = 2.0*constants[77]*(algebraic_variables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic_variables[8]-0.0)*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic_variables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic_variables[41] = (algebraic_variables[38]+algebraic_variables[67]+algebraic_variables[5])*(1.0-computed_constants[19])*1.0*computed_constants[18] + algebraic_variables[37] = 2.0*constants[84]*algebraic_variables[8]/(computed_constants[0]*(1.0-exp(-algebraic_variables[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic_variables[8]/computed_constants[0]))*states[25]*states[24] + algebraic_variables[5] = 0.0000185*constants[77]*algebraic_variables[8]/(computed_constants[0]*(1.0-exp(-algebraic_variables[8]/computed_constants[0])))*(algebraic_variables[0]-constants[2]*exp(-algebraic_variables[8]/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic_variables[67] = 0.000365*constants[77]*algebraic_variables[8]/(computed_constants[0]*(1.0-exp(-algebraic_variables[8]/computed_constants[0])))*(constants[3]-constants[4]*exp(-algebraic_variables[8]/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic_variables[38] = 2.0*constants[77]*algebraic_variables[8]/(computed_constants[0]*(1.0-exp(-algebraic_variables[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic_variables[8]/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic_variables[41] = (algebraic_variables[38]+algebraic_variables[67]+algebraic_variables[5])*(1.0-computed_constants[19])*computed_constants[18] algebraic_variables[51] = computed_constants[0]*log((constants[2]+0.12*constants[4])/(algebraic_variables[0]+0.12*constants[3])) algebraic_variables[53] = constants[74]*pow(states[18], 3.0)*(algebraic_variables[8]-algebraic_variables[51]) algebraic_variables[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic_variables[8]-algebraic_variables[51]) @@ -655,8 +655,8 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic_variables[45] = algebraic_variables[6]+algebraic_variables[48] algebraic_variables[46] = algebraic_variables[45]+algebraic_variables[44]+algebraic_variables[43]+algebraic_variables[42]+algebraic_variables[4]+algebraic_variables[3]+algebraic_variables[7]+algebraic_variables[41]+algebraic_variables[37]+algebraic_variables[40]+algebraic_variables[39] algebraic_variables[49] = 1.0/(0.36*(algebraic_variables[8]+148.8-computed_constants[16]-computed_constants[17])/(exp(0.066*(algebraic_variables[8]+148.8-computed_constants[16]-computed_constants[17]))-1.0)+0.1*(algebraic_variables[8]+87.3-computed_constants[16]-computed_constants[17])/(1.0-exp(-0.2*(algebraic_variables[8]+87.3-computed_constants[16]-computed_constants[17]))))-0.054 - algebraic_variables[50] = 0.01329+0.99921/(1.0+exp((algebraic_variables[8]+97.134-computed_constants[16]-computed_constants[17]-constants[72])/8.1752)) if lt_func(algebraic_variables[8], -(80.0-computed_constants[16]-computed_constants[17]-constants[72])) else 0.0002501*exp(-(algebraic_variables[8]-computed_constants[16]-computed_constants[17]-constants[72])/12.861) - algebraic_variables[54] = 1.0/(1.0+exp(-(algebraic_variables[8]+42.0504)/8.3106)) + algebraic_variables[50] = 0.01329+0.99921/(1.0+exp((algebraic_variables[8]+97.134-computed_constants[16]-computed_constants[17]-constants[72])/8.1752)) if lt_func(algebraic_variables[8], -80.0+computed_constants[16]+computed_constants[17]+constants[72]) else 0.0002501*exp((-algebraic_variables[8]+computed_constants[16]+computed_constants[17]+constants[72])/12.861) + algebraic_variables[54] = 1.0/(1.0+exp((-algebraic_variables[8]-42.0504)/8.3106)) algebraic_variables[55] = algebraic_variables[8]+41.0 algebraic_variables[56] = 2000.0 if lt_func(fabs(algebraic_variables[55]), constants[75]) else 200.0*algebraic_variables[55]/(1.0-exp(-0.1*algebraic_variables[55])) algebraic_variables[57] = 8000.0*exp(-0.056*(algebraic_variables[8]+66.0)) @@ -669,34 +669,34 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic_variables[63] = 0.009/(1.0+exp((algebraic_variables[8]+5.0)/12.0))+0.0005 algebraic_variables[66] = 1.0/(1.0+exp((algebraic_variables[8]+7.5)/10.0)) algebraic_variables[65] = 0.59/(1.0+exp((algebraic_variables[8]+60.0)/10.0))+3.05 - algebraic_variables[68] = 1.0/(1.0+exp(-(algebraic_variables[8]-constants[79]-computed_constants[20])/(constants[78]*(1.0+computed_constants[21]/100.0)))) + algebraic_variables[68] = 1.0/(1.0+exp((-algebraic_variables[8]+constants[79]+computed_constants[20])/(constants[78]*(1.0+computed_constants[21]/100.0)))) algebraic_variables[73] = -1.80001 if eq_func(algebraic_variables[8], -1.8) else algebraic_variables[8] algebraic_variables[69] = 0.01143*(algebraic_variables[73]+1.8)/(exp((algebraic_variables[73]+1.8)/2.5)-1.0) algebraic_variables[72] = -41.80001 if eq_func(algebraic_variables[8], -41.8) else 0.0 if eq_func(algebraic_variables[8], 0.0) else -6.80001 if eq_func(algebraic_variables[8], -6.8) else algebraic_variables[8] - algebraic_variables[70] = -0.02839*(algebraic_variables[72]+41.8)/(exp(-(algebraic_variables[72]+41.8)/2.5)-1.0)-0.0849*(algebraic_variables[72]+6.8)/(exp(-(algebraic_variables[72]+6.8)/4.8)-1.0) + algebraic_variables[70] = -0.02839*(algebraic_variables[72]+41.8)/(exp((-algebraic_variables[72]-41.8)/2.5)-1.0)-0.0849*(algebraic_variables[72]+6.8)/(exp((-algebraic_variables[72]-6.8)/4.8)-1.0) algebraic_variables[71] = 0.001/(algebraic_variables[70]+algebraic_variables[69]) algebraic_variables[74] = 1.0/(1.0+exp((algebraic_variables[8]+37.4+constants[81])/(5.3+constants[80]))) algebraic_variables[75] = 0.001*(44.3+230.0*exp(-pow((algebraic_variables[8]+36.0)/10.0, 2.0))) algebraic_variables[76] = constants[82]/(constants[82]+states[0]) algebraic_variables[77] = 0.001*algebraic_variables[76]/constants[83] - algebraic_variables[78] = 1.0/(1.0+exp(-(algebraic_variables[8]+38.3)/5.5)) - algebraic_variables[79] = 0.001/(1.068*exp((algebraic_variables[8]+38.3)/30.0)+1.068*exp(-(algebraic_variables[8]+38.3)/30.0)) + algebraic_variables[78] = 1.0/(1.0+exp((-algebraic_variables[8]-38.3)/5.5)) + algebraic_variables[79] = 0.001/(1.068*exp((algebraic_variables[8]+38.3)/30.0)+1.068*exp((-algebraic_variables[8]-38.3)/30.0)) algebraic_variables[80] = 1.0/(1.0+exp((algebraic_variables[8]+58.7)/3.8)) - algebraic_variables[81] = 1.0/(16.67*exp(-(algebraic_variables[8]+75.0)/83.3)+16.67*exp((algebraic_variables[8]+75.0)/15.38))+constants[85] + algebraic_variables[81] = 1.0/(16.67*exp((-algebraic_variables[8]-75.0)/83.3)+16.67*exp((algebraic_variables[8]+75.0)/15.38))+constants[85] algebraic_variables[82] = 1.0/(1.0+exp((algebraic_variables[8]+49.0)/13.0)) algebraic_variables[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic_variables[8]+44.0))+0.065*exp(0.1*(algebraic_variables[8]+45.93)))+10.1) - algebraic_variables[84] = 1.0/(1.0+exp(-(algebraic_variables[8]-19.3)/15.0)) + algebraic_variables[84] = 1.0/(1.0+exp((-algebraic_variables[8]+19.3)/15.0)) algebraic_variables[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic_variables[8]+30.61))+0.369*exp(-0.12*(algebraic_variables[8]+23.84)))+2.98) - algebraic_variables[86] = 1.0/(1.0+exp(-(algebraic_variables[8]+23.2)/6.6))/(0.84655354/(37.2*exp(algebraic_variables[8]/11.9)+0.96*exp(-algebraic_variables[8]/18.5))) - algebraic_variables[87] = 4.0*((37.2*exp(algebraic_variables[8]/15.9)+0.96*exp(-algebraic_variables[8]/22.5))/0.84655354-1.0/(1.0+exp(-(algebraic_variables[8]+23.2)/10.6))/(0.84655354/(37.2*exp(algebraic_variables[8]/15.9)+0.96*exp(-algebraic_variables[8]/22.5)))) - algebraic_variables[88] = 1.0/(1.0+exp(-(algebraic_variables[8]+10.0144)/7.6607)) + algebraic_variables[86] = 1.0/(1.0+exp((-algebraic_variables[8]-23.2)/6.6))/(0.84655354/(37.2*exp(algebraic_variables[8]/11.9)+0.96*exp(-algebraic_variables[8]/18.5))) + algebraic_variables[87] = 4.0*((37.2*exp(algebraic_variables[8]/15.9)+0.96*exp(-algebraic_variables[8]/22.5))/0.84655354-1.0/(1.0+exp((-algebraic_variables[8]-23.2)/10.6))/(0.84655354/(37.2*exp(algebraic_variables[8]/15.9)+0.96*exp(-algebraic_variables[8]/22.5)))) + algebraic_variables[88] = 1.0/(1.0+exp((-algebraic_variables[8]-10.0144)/7.6607)) algebraic_variables[89] = 0.84655354/(4.2*exp(algebraic_variables[8]/17.0)+0.15*exp(-algebraic_variables[8]/21.6)) algebraic_variables[90] = 1.0/(30.0*exp(algebraic_variables[8]/10.0)+exp(-algebraic_variables[8]/12.0)) algebraic_variables[91] = 1.0/(100.0*exp(-algebraic_variables[8]/54.645)+656.0*exp(algebraic_variables[8]/106.157)) algebraic_variables[92] = 1.0/(1.0+exp((algebraic_variables[8]+28.6)/17.1)) - algebraic_variables[94] = sqrt(1.0/(1.0+exp(-(algebraic_variables[8]+0.6383-computed_constants[23])/10.7071))) - algebraic_variables[95] = 1.0*exp(-(algebraic_variables[8]-computed_constants[23]-5.0)/25.0) - algebraic_variables[96] = 28.0/(1.0+exp(-(algebraic_variables[8]-40.0-computed_constants[23])/3.0)) + algebraic_variables[94] = sqrt(1.0/(1.0+exp((-algebraic_variables[8]-0.6383+computed_constants[23])/10.7071))) + algebraic_variables[95] = exp((-algebraic_variables[8]+computed_constants[23]+5.0)/25.0) + algebraic_variables[96] = 28.0/(1.0+exp((-algebraic_variables[8]+40.0+computed_constants[23])/3.0)) algebraic_variables[97] = 1.0/(algebraic_variables[96]+algebraic_variables[95]) algebraic_variables[98] = 10.0*exp(0.0133*(algebraic_variables[8]+40.0)) algebraic_variables[99] = computed_constants[24]/(computed_constants[24]+algebraic_variables[98]) diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index e4bbe6da2a..75f250711e 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 @@ -407,7 +407,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - 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[0] = (constants[1] == 0.0)?1.07*(3.0*constants[0]-0.1)/(3.0*(1.0+0.7745*exp((-3.0*constants[0]+2.05)/0.295))):(constants[1] == 1.0)?constants[2]*constants[0]/(1.0+0.7745*exp((-3.0*constants[0]+2.05)/0.295)):1.07*29.0*constants[0]/(30.0*(1.0+0.7745*exp((-29.0*constants[0]+24.5)/1.95))); computedConstants[1] = constants[3]+computedConstants[0]*(constants[4]-constants[3]); computedConstants[3] = (constants[1] == 0.0)?constants[8]+computedConstants[0]*(constants[9]-constants[8]):(constants[1] == 1.0)?constants[12]+computedConstants[0]*(constants[13]-constants[12]):constants[10]+computedConstants[0]*(constants[11]-constants[10]); computedConstants[5] = (constants[1] == 0.0)?constants[14]+computedConstants[0]*(constants[15]-constants[14]):(constants[1] == 1.0)?constants[18]+computedConstants[0]*(constants[19]-constants[18]):constants[16]+computedConstants[0]*(constants[17]-constants[16]); @@ -434,26 +434,26 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraicVariables[0] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); + algebraicVariables[0] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp((-states[0]-60.0)/40.0)); algebraicVariables[1] = (constants[1] == 0.0)?computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))):computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))); + algebraicVariables[2] = computedConstants[5]*(states[0]-computedConstants[6]); + algebraicVariables[3] = computedConstants[7]*(states[0]-computedConstants[8]); + algebraicVariables[4] = computedConstants[3]*(states[0]-computedConstants[4]); algebraicVariables[5] = (constants[1] != 2.0)?computedConstants[22]*states[14]*(states[0]-computedConstants[6]):computedConstants[22]*states[14]*(states[0]+102.0); algebraicVariables[6] = (constants[1] != 2.0)?computedConstants[21]*states[14]*(states[0]-computedConstants[4]):computedConstants[21]*states[14]*(states[0]-77.6); algebraicVariables[7] = computedConstants[20]*pow(states[13], 2.0)*(states[0]-computedConstants[12]); + algebraicVariables[42] = 0.6*states[12]+0.4*states[11]; + algebraicVariables[8] = computedConstants[18]*algebraicVariables[42]*states[10]*(states[0]-computedConstants[6]); algebraicVariables[9] = computedConstants[17]*states[8]*(states[0]-computedConstants[6]); algebraicVariables[10] = computedConstants[16]*states[9]*states[8]*(states[0]-computedConstants[6]); algebraicVariables[11] = computedConstants[15]*states[7]*states[6]*(states[0]-constants[73]); - algebraicVariables[12] = computedConstants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]); - algebraicVariables[2] = computedConstants[5]*(states[0]-computedConstants[6]); - algebraicVariables[3] = computedConstants[7]*(states[0]-computedConstants[8]); - algebraicVariables[4] = computedConstants[3]*(states[0]-computedConstants[4]); - algebraicVariables[42] = 0.6*states[12]+0.4*states[11]; - algebraicVariables[8] = computedConstants[18]*algebraicVariables[42]*states[10]*(states[0]-computedConstants[6]); + algebraicVariables[12] = computedConstants[14]*(states[5]*states[4]+0.006/(1.0+exp((-states[0]-14.1)/6.0)))*(states[0]-constants[66]); algebraicVariables[17] = (constants[1] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; algebraicVariables[14] = (1.0-algebraicVariables[17])*states[3]+algebraicVariables[17]*states[2]; algebraicVariables[13] = computedConstants[13]*pow(states[1], 3.0)*algebraicVariables[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computedConstants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0]; rates[0] = -1.0/computedConstants[1]*(algebraicVariables[13]+algebraicVariables[12]+algebraicVariables[11]+algebraicVariables[10]+algebraicVariables[9]+algebraicVariables[8]+algebraicVariables[7]+algebraicVariables[6]+algebraicVariables[5]+algebraicVariables[4]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1]+algebraicVariables[0]+computedConstants[2]); algebraicVariables[15] = (constants[1] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; - algebraicVariables[16] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); + algebraicVariables[16] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 0.333333333333333):pow(1.0/(1.0+exp((-states[0]-30.32)/5.46)), 0.333333333333333); rates[1] = (algebraicVariables[16]-states[1])/algebraicVariables[15]; algebraicVariables[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; algebraicVariables[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); @@ -462,44 +462,44 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraicVariables[21] = algebraicVariables[19]; rates[2] = (algebraicVariables[21]-states[2])/algebraicVariables[20]; algebraicVariables[25] = (constants[1] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); - algebraicVariables[24] = (constants[1] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[1] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); + algebraicVariables[24] = (constants[1] == 0.0)?-28.38*(states[0]+35.0)/(exp((-states[0]-35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[1] == 1.0)?-28.39*(states[0]+35.0)/(exp((-states[0]-35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp((-states[0]-35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); algebraicVariables[22] = 2.0/(algebraicVariables[24]+algebraicVariables[25]); - algebraicVariables[23] = (constants[1] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); + algebraicVariables[23] = (constants[1] == 0.0)?1.0/(1.0+exp((-states[0]-23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp((-states[0]-22.3-0.8*computedConstants[0])/6.0)):1.0/(1.0+exp((-states[0]-22.2)/6.0)); rates[4] = (algebraicVariables[23]-states[4])/algebraicVariables[22]; - algebraicVariables[29] = (constants[1] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); + algebraicVariables[29] = (constants[1] == 1.0)?30.0/(1.0+exp((-states[0]-28.0)/4.0)):25.0/(1.0+exp((-states[0]-28.0)/4.0)); algebraicVariables[28] = (constants[1] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); algebraicVariables[26] = (constants[1] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraicVariables[28]+algebraicVariables[29]):1.0/(algebraicVariables[28]+algebraicVariables[29]); algebraicVariables[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); rates[5] = (algebraicVariables[27]-states[5])/algebraicVariables[26]; - algebraicVariables[33] = 1068.0*exp(-(states[0]+26.3)/30.0); + algebraicVariables[33] = 1068.0*exp((-states[0]-26.3)/30.0); algebraicVariables[32] = 1068.0*exp((states[0]+26.3)/30.0); algebraicVariables[30] = 1.0/(algebraicVariables[32]+algebraicVariables[33]); - algebraicVariables[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); + algebraicVariables[31] = 1.0/(1.0+exp((-states[0]-37.0)/6.8)); rates[7] = (algebraicVariables[31]-states[7])/algebraicVariables[30]; algebraicVariables[37] = (constants[1] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); - algebraicVariables[36] = (constants[1] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); + algebraicVariables[36] = (constants[1] == 1.0)?15.3*exp((-states[0]-71.0-0.7*computedConstants[0])/83.3):15.3*exp((-states[0]-71.7)/83.3); algebraicVariables[34] = 1.0/(algebraicVariables[36]+algebraicVariables[37]); algebraicVariables[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); rates[6] = (algebraicVariables[35]-states[6])/algebraicVariables[34]; - algebraicVariables[38] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); + algebraicVariables[38] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.000333333333333333*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); algebraicVariables[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); rates[9] = (algebraicVariables[39]-states[9])/algebraicVariables[38]; algebraicVariables[40] = (constants[1] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[1] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); - algebraicVariables[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); + algebraicVariables[41] = 1.0/(1.0+exp((-states[0]+10.93)/19.7)); rates[8] = (algebraicVariables[41]-states[8])/algebraicVariables[40]; - algebraicVariables[43] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); - algebraicVariables[44] = (constants[1] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); + algebraicVariables[43] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp((-states[0]+9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp((-states[0]+10.0)/22.5)); + algebraicVariables[44] = (constants[1] != 2.0)?1.0/(1.0+exp((-states[0]-14.2)/10.6)):1.0/(1.0+exp((-states[0]-13.2)/10.6)); rates[12] = (algebraicVariables[44]-states[12])/algebraicVariables[43]; - algebraicVariables[45] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); + algebraicVariables[45] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp((-states[0]+9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp((-states[0]+10.0)/21.6)); algebraicVariables[46] = algebraicVariables[44]; rates[11] = (algebraicVariables[46]-states[11])/algebraicVariables[45]; algebraicVariables[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); rates[10] = (algebraicVariables[47]-states[10])/computedConstants[19]; - algebraicVariables[48] = 1.0*exp(-states[0]/45.0); - algebraicVariables[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); + algebraicVariables[48] = exp(-states[0]/45.0); + algebraicVariables[49] = 14.0/(1.0+exp((-states[0]+40.0)/9.0)); rates[13] = algebraicVariables[49]*(1.0-states[13])-algebraicVariables[48]*states[13]; - algebraicVariables[50] = 1.0*exp((states[0]+75.13)/21.25); - algebraicVariables[51] = (constants[1] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); + algebraicVariables[50] = exp((states[0]+75.13)/21.25); + algebraicVariables[51] = (constants[1] == 0.0)?exp((-states[0]-78.91)/26.62):exp((-states[0]-78.91)/26.63); rates[14] = algebraicVariables[51]*(1.0-states[14])-algebraicVariables[50]*states[14]; } @@ -509,52 +509,52 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraicVariables[2] = computedConstants[5]*(states[0]-computedConstants[6]); algebraicVariables[3] = computedConstants[7]*(states[0]-computedConstants[8]); algebraicVariables[1] = (constants[1] == 0.0)?computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))):computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))); - algebraicVariables[0] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); + algebraicVariables[0] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp((-states[0]-60.0)/40.0)); algebraicVariables[17] = (constants[1] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; algebraicVariables[14] = (1.0-algebraicVariables[17])*states[3]+algebraicVariables[17]*states[2]; algebraicVariables[13] = computedConstants[13]*pow(states[1], 3.0)*algebraicVariables[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computedConstants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0]; - algebraicVariables[16] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); + algebraicVariables[16] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 0.333333333333333):pow(1.0/(1.0+exp((-states[0]-30.32)/5.46)), 0.333333333333333); algebraicVariables[15] = (constants[1] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; algebraicVariables[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); algebraicVariables[21] = algebraicVariables[19]; algebraicVariables[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; algebraicVariables[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; - algebraicVariables[12] = computedConstants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]); - algebraicVariables[24] = (constants[1] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[1] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); + algebraicVariables[12] = computedConstants[14]*(states[5]*states[4]+0.006/(1.0+exp((-states[0]-14.1)/6.0)))*(states[0]-constants[66]); + algebraicVariables[24] = (constants[1] == 0.0)?-28.38*(states[0]+35.0)/(exp((-states[0]-35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[1] == 1.0)?-28.39*(states[0]+35.0)/(exp((-states[0]-35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp((-states[0]-35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); algebraicVariables[25] = (constants[1] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); algebraicVariables[22] = 2.0/(algebraicVariables[24]+algebraicVariables[25]); - algebraicVariables[23] = (constants[1] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); + algebraicVariables[23] = (constants[1] == 0.0)?1.0/(1.0+exp((-states[0]-23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp((-states[0]-22.3-0.8*computedConstants[0])/6.0)):1.0/(1.0+exp((-states[0]-22.2)/6.0)); algebraicVariables[28] = (constants[1] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); - algebraicVariables[29] = (constants[1] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); + algebraicVariables[29] = (constants[1] == 1.0)?30.0/(1.0+exp((-states[0]-28.0)/4.0)):25.0/(1.0+exp((-states[0]-28.0)/4.0)); algebraicVariables[26] = (constants[1] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraicVariables[28]+algebraicVariables[29]):1.0/(algebraicVariables[28]+algebraicVariables[29]); algebraicVariables[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); algebraicVariables[11] = computedConstants[15]*states[7]*states[6]*(states[0]-constants[73]); algebraicVariables[32] = 1068.0*exp((states[0]+26.3)/30.0); - algebraicVariables[33] = 1068.0*exp(-(states[0]+26.3)/30.0); + algebraicVariables[33] = 1068.0*exp((-states[0]-26.3)/30.0); algebraicVariables[30] = 1.0/(algebraicVariables[32]+algebraicVariables[33]); - algebraicVariables[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); - algebraicVariables[36] = (constants[1] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); + algebraicVariables[31] = 1.0/(1.0+exp((-states[0]-37.0)/6.8)); + algebraicVariables[36] = (constants[1] == 1.0)?15.3*exp((-states[0]-71.0-0.7*computedConstants[0])/83.3):15.3*exp((-states[0]-71.7)/83.3); algebraicVariables[37] = (constants[1] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); algebraicVariables[34] = 1.0/(algebraicVariables[36]+algebraicVariables[37]); algebraicVariables[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); algebraicVariables[10] = computedConstants[16]*states[9]*states[8]*(states[0]-computedConstants[6]); algebraicVariables[9] = computedConstants[17]*states[8]*(states[0]-computedConstants[6]); algebraicVariables[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); - algebraicVariables[38] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); - algebraicVariables[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); + algebraicVariables[38] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.000333333333333333*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); + algebraicVariables[41] = 1.0/(1.0+exp((-states[0]+10.93)/19.7)); algebraicVariables[40] = (constants[1] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[1] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); algebraicVariables[42] = 0.6*states[12]+0.4*states[11]; algebraicVariables[8] = computedConstants[18]*algebraicVariables[42]*states[10]*(states[0]-computedConstants[6]); - algebraicVariables[44] = (constants[1] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); - algebraicVariables[43] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); + algebraicVariables[44] = (constants[1] != 2.0)?1.0/(1.0+exp((-states[0]-14.2)/10.6)):1.0/(1.0+exp((-states[0]-13.2)/10.6)); + algebraicVariables[43] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp((-states[0]+9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp((-states[0]+10.0)/22.5)); algebraicVariables[46] = algebraicVariables[44]; - algebraicVariables[45] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); + algebraicVariables[45] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp((-states[0]+9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp((-states[0]+10.0)/21.6)); algebraicVariables[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); algebraicVariables[7] = computedConstants[20]*pow(states[13], 2.0)*(states[0]-computedConstants[12]); - algebraicVariables[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); - algebraicVariables[48] = 1.0*exp(-states[0]/45.0); + algebraicVariables[49] = 14.0/(1.0+exp((-states[0]+40.0)/9.0)); + algebraicVariables[48] = exp(-states[0]/45.0); algebraicVariables[6] = (constants[1] != 2.0)?computedConstants[21]*states[14]*(states[0]-computedConstants[4]):computedConstants[21]*states[14]*(states[0]-77.6); algebraicVariables[5] = (constants[1] != 2.0)?computedConstants[22]*states[14]*(states[0]-computedConstants[6]):computedConstants[22]*states[14]*(states[0]+102.0); - algebraicVariables[51] = (constants[1] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); - algebraicVariables[50] = 1.0*exp((states[0]+75.13)/21.25); + algebraicVariables[51] = (constants[1] == 0.0)?exp((-states[0]-78.91)/26.62):exp((-states[0]-78.91)/26.63); + algebraicVariables[50] = exp((states[0]+75.13)/21.25); } diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 01a8eac181..1aa460d9fe 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 @@ -380,7 +380,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): - 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[0] = 1.07*(3.0*constants[0]-0.1)/(3.0*(1.0+0.7745*exp((-3.0*constants[0]+2.05)/0.295))) if eq_func(constants[1], 0.0) else constants[2]*constants[0]/(1.0+0.7745*exp((-3.0*constants[0]+2.05)/0.295)) if eq_func(constants[1], 1.0) else 1.07*29.0*constants[0]/(30.0*(1.0+0.7745*exp((-29.0*constants[0]+24.5)/1.95))) computed_constants[1] = constants[3]+computed_constants[0]*(constants[4]-constants[3]) computed_constants[3] = constants[8]+computed_constants[0]*(constants[9]-constants[8]) if eq_func(constants[1], 0.0) else constants[12]+computed_constants[0]*(constants[13]-constants[12]) if eq_func(constants[1], 1.0) else constants[10]+computed_constants[0]*(constants[11]-constants[10]) computed_constants[5] = constants[14]+computed_constants[0]*(constants[15]-constants[14]) if eq_func(constants[1], 0.0) else constants[18]+computed_constants[0]*(constants[19]-constants[18]) if eq_func(constants[1], 1.0) else constants[16]+computed_constants[0]*(constants[17]-constants[16]) @@ -406,26 +406,26 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - algebraic_variables[0] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) + algebraic_variables[0] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp((-states[0]-60.0)/40.0)) algebraic_variables[1] = computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) if eq_func(constants[1], 0.0) else computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) + algebraic_variables[2] = computed_constants[5]*(states[0]-computed_constants[6]) + algebraic_variables[3] = computed_constants[7]*(states[0]-computed_constants[8]) + algebraic_variables[4] = computed_constants[3]*(states[0]-computed_constants[4]) algebraic_variables[5] = computed_constants[22]*states[14]*(states[0]-computed_constants[6]) if neq_func(constants[1], 2.0) else computed_constants[22]*states[14]*(states[0]+102.0) algebraic_variables[6] = computed_constants[21]*states[14]*(states[0]-computed_constants[4]) if neq_func(constants[1], 2.0) else computed_constants[21]*states[14]*(states[0]-77.6) algebraic_variables[7] = computed_constants[20]*pow(states[13], 2.0)*(states[0]-computed_constants[12]) + algebraic_variables[42] = 0.6*states[12]+0.4*states[11] + algebraic_variables[8] = computed_constants[18]*algebraic_variables[42]*states[10]*(states[0]-computed_constants[6]) algebraic_variables[9] = computed_constants[17]*states[8]*(states[0]-computed_constants[6]) algebraic_variables[10] = computed_constants[16]*states[9]*states[8]*(states[0]-computed_constants[6]) algebraic_variables[11] = computed_constants[15]*states[7]*states[6]*(states[0]-constants[73]) - algebraic_variables[12] = computed_constants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]) - algebraic_variables[2] = computed_constants[5]*(states[0]-computed_constants[6]) - algebraic_variables[3] = computed_constants[7]*(states[0]-computed_constants[8]) - algebraic_variables[4] = computed_constants[3]*(states[0]-computed_constants[4]) - algebraic_variables[42] = 0.6*states[12]+0.4*states[11] - algebraic_variables[8] = computed_constants[18]*algebraic_variables[42]*states[10]*(states[0]-computed_constants[6]) + algebraic_variables[12] = computed_constants[14]*(states[5]*states[4]+0.006/(1.0+exp((-states[0]-14.1)/6.0)))*(states[0]-constants[66]) algebraic_variables[17] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[1], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 algebraic_variables[14] = (1.0-algebraic_variables[17])*states[3]+algebraic_variables[17]*states[2] algebraic_variables[13] = computed_constants[13]*pow(states[1], 3.0)*algebraic_variables[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computed_constants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0] rates[0] = -1.0/computed_constants[1]*(algebraic_variables[13]+algebraic_variables[12]+algebraic_variables[11]+algebraic_variables[10]+algebraic_variables[9]+algebraic_variables[8]+algebraic_variables[7]+algebraic_variables[6]+algebraic_variables[5]+algebraic_variables[4]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1]+algebraic_variables[0]+computed_constants[2]) algebraic_variables[15] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[1], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 - algebraic_variables[16] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) + algebraic_variables[16] = pow(1.0/(1.0+exp(-states[0]/5.46)), 0.333333333333333) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp((-states[0]-30.32)/5.46)), 0.333333333333333) rates[1] = (algebraic_variables[16]-states[1])/algebraic_variables[15] algebraic_variables[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 algebraic_variables[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) @@ -434,44 +434,44 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v algebraic_variables[21] = algebraic_variables[19] rates[2] = (algebraic_variables[21]-states[2])/algebraic_variables[20] algebraic_variables[25] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[1], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) - algebraic_variables[24] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) + algebraic_variables[24] = -28.38*(states[0]+35.0)/(exp((-states[0]-35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 0.0) else -28.39*(states[0]+35.0)/(exp((-states[0]-35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 1.0) else -28.4*(states[0]+35.0)/(exp((-states[0]-35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) algebraic_variables[22] = 2.0/(algebraic_variables[24]+algebraic_variables[25]) - algebraic_variables[23] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) + algebraic_variables[23] = 1.0/(1.0+exp((-states[0]-23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp((-states[0]-22.3-0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp((-states[0]-22.2)/6.0)) rates[4] = (algebraic_variables[23]-states[4])/algebraic_variables[22] - algebraic_variables[29] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[1], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) + algebraic_variables[29] = 30.0/(1.0+exp((-states[0]-28.0)/4.0)) if eq_func(constants[1], 1.0) else 25.0/(1.0+exp((-states[0]-28.0)/4.0)) algebraic_variables[28] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[1], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) algebraic_variables[26] = (1.2-0.2*computed_constants[0])/(algebraic_variables[28]+algebraic_variables[29]) if eq_func(constants[1], 1.0) else 1.0/(algebraic_variables[28]+algebraic_variables[29]) algebraic_variables[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) rates[5] = (algebraic_variables[27]-states[5])/algebraic_variables[26] - algebraic_variables[33] = 1068.0*exp(-(states[0]+26.3)/30.0) + algebraic_variables[33] = 1068.0*exp((-states[0]-26.3)/30.0) algebraic_variables[32] = 1068.0*exp((states[0]+26.3)/30.0) algebraic_variables[30] = 1.0/(algebraic_variables[32]+algebraic_variables[33]) - algebraic_variables[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) + algebraic_variables[31] = 1.0/(1.0+exp((-states[0]-37.0)/6.8)) rates[7] = (algebraic_variables[31]-states[7])/algebraic_variables[30] algebraic_variables[37] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[1], 1.0) else 15.0*exp((states[0]+71.7)/15.38) - algebraic_variables[36] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[1], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) + algebraic_variables[36] = 15.3*exp((-states[0]-71.0-0.7*computed_constants[0])/83.3) if eq_func(constants[1], 1.0) else 15.3*exp((-states[0]-71.7)/83.3) algebraic_variables[34] = 1.0/(algebraic_variables[36]+algebraic_variables[37]) algebraic_variables[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) rates[6] = (algebraic_variables[35]-states[6])/algebraic_variables[34] - algebraic_variables[38] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) + algebraic_variables[38] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.000333333333333333*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) algebraic_variables[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) rates[9] = (algebraic_variables[39]-states[9])/algebraic_variables[38] algebraic_variables[40] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[1], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[1], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) - algebraic_variables[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) + algebraic_variables[41] = 1.0/(1.0+exp((-states[0]+10.93)/19.7)) rates[8] = (algebraic_variables[41]-states[8])/algebraic_variables[40] - algebraic_variables[43] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) - algebraic_variables[44] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) + algebraic_variables[43] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp((-states[0]+9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp((-states[0]+10.0)/22.5)) + algebraic_variables[44] = 1.0/(1.0+exp((-states[0]-14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp((-states[0]-13.2)/10.6)) rates[12] = (algebraic_variables[44]-states[12])/algebraic_variables[43] - algebraic_variables[45] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) + algebraic_variables[45] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp((-states[0]+9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp((-states[0]+10.0)/21.6)) algebraic_variables[46] = algebraic_variables[44] rates[11] = (algebraic_variables[46]-states[11])/algebraic_variables[45] algebraic_variables[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) rates[10] = (algebraic_variables[47]-states[10])/computed_constants[19] - algebraic_variables[48] = 1.0*exp(-states[0]/45.0) - algebraic_variables[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) + algebraic_variables[48] = exp(-states[0]/45.0) + algebraic_variables[49] = 14.0/(1.0+exp((-states[0]+40.0)/9.0)) rates[13] = algebraic_variables[49]*(1.0-states[13])-algebraic_variables[48]*states[13] - algebraic_variables[50] = 1.0*exp((states[0]+75.13)/21.25) - algebraic_variables[51] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[1], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) + algebraic_variables[50] = exp((states[0]+75.13)/21.25) + algebraic_variables[51] = exp((-states[0]-78.91)/26.62) if eq_func(constants[1], 0.0) else exp((-states[0]-78.91)/26.63) rates[14] = algebraic_variables[51]*(1.0-states[14])-algebraic_variables[50]*states[14] @@ -480,51 +480,51 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic_variables[2] = computed_constants[5]*(states[0]-computed_constants[6]) algebraic_variables[3] = computed_constants[7]*(states[0]-computed_constants[8]) algebraic_variables[1] = computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) if eq_func(constants[1], 0.0) else computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) - algebraic_variables[0] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) + algebraic_variables[0] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp((-states[0]-60.0)/40.0)) algebraic_variables[17] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[1], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 algebraic_variables[14] = (1.0-algebraic_variables[17])*states[3]+algebraic_variables[17]*states[2] algebraic_variables[13] = computed_constants[13]*pow(states[1], 3.0)*algebraic_variables[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computed_constants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0] - algebraic_variables[16] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) + algebraic_variables[16] = pow(1.0/(1.0+exp(-states[0]/5.46)), 0.333333333333333) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp((-states[0]-30.32)/5.46)), 0.333333333333333) algebraic_variables[15] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[1], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 algebraic_variables[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) algebraic_variables[21] = algebraic_variables[19] algebraic_variables[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 algebraic_variables[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 - algebraic_variables[12] = computed_constants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]) - algebraic_variables[24] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) + algebraic_variables[12] = computed_constants[14]*(states[5]*states[4]+0.006/(1.0+exp((-states[0]-14.1)/6.0)))*(states[0]-constants[66]) + algebraic_variables[24] = -28.38*(states[0]+35.0)/(exp((-states[0]-35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 0.0) else -28.39*(states[0]+35.0)/(exp((-states[0]-35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 1.0) else -28.4*(states[0]+35.0)/(exp((-states[0]-35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) algebraic_variables[25] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[1], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) algebraic_variables[22] = 2.0/(algebraic_variables[24]+algebraic_variables[25]) - algebraic_variables[23] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) + algebraic_variables[23] = 1.0/(1.0+exp((-states[0]-23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp((-states[0]-22.3-0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp((-states[0]-22.2)/6.0)) algebraic_variables[28] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[1], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) - algebraic_variables[29] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[1], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) + algebraic_variables[29] = 30.0/(1.0+exp((-states[0]-28.0)/4.0)) if eq_func(constants[1], 1.0) else 25.0/(1.0+exp((-states[0]-28.0)/4.0)) algebraic_variables[26] = (1.2-0.2*computed_constants[0])/(algebraic_variables[28]+algebraic_variables[29]) if eq_func(constants[1], 1.0) else 1.0/(algebraic_variables[28]+algebraic_variables[29]) algebraic_variables[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) algebraic_variables[11] = computed_constants[15]*states[7]*states[6]*(states[0]-constants[73]) algebraic_variables[32] = 1068.0*exp((states[0]+26.3)/30.0) - algebraic_variables[33] = 1068.0*exp(-(states[0]+26.3)/30.0) + algebraic_variables[33] = 1068.0*exp((-states[0]-26.3)/30.0) algebraic_variables[30] = 1.0/(algebraic_variables[32]+algebraic_variables[33]) - algebraic_variables[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) - algebraic_variables[36] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[1], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) + algebraic_variables[31] = 1.0/(1.0+exp((-states[0]-37.0)/6.8)) + algebraic_variables[36] = 15.3*exp((-states[0]-71.0-0.7*computed_constants[0])/83.3) if eq_func(constants[1], 1.0) else 15.3*exp((-states[0]-71.7)/83.3) algebraic_variables[37] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[1], 1.0) else 15.0*exp((states[0]+71.7)/15.38) algebraic_variables[34] = 1.0/(algebraic_variables[36]+algebraic_variables[37]) algebraic_variables[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) algebraic_variables[10] = computed_constants[16]*states[9]*states[8]*(states[0]-computed_constants[6]) algebraic_variables[9] = computed_constants[17]*states[8]*(states[0]-computed_constants[6]) algebraic_variables[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) - algebraic_variables[38] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) - algebraic_variables[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) + algebraic_variables[38] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.000333333333333333*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) + algebraic_variables[41] = 1.0/(1.0+exp((-states[0]+10.93)/19.7)) algebraic_variables[40] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[1], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[1], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) algebraic_variables[42] = 0.6*states[12]+0.4*states[11] algebraic_variables[8] = computed_constants[18]*algebraic_variables[42]*states[10]*(states[0]-computed_constants[6]) - algebraic_variables[44] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) - algebraic_variables[43] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) + algebraic_variables[44] = 1.0/(1.0+exp((-states[0]-14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp((-states[0]-13.2)/10.6)) + algebraic_variables[43] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp((-states[0]+9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp((-states[0]+10.0)/22.5)) algebraic_variables[46] = algebraic_variables[44] - algebraic_variables[45] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) + algebraic_variables[45] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp((-states[0]+9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp((-states[0]+10.0)/21.6)) algebraic_variables[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) algebraic_variables[7] = computed_constants[20]*pow(states[13], 2.0)*(states[0]-computed_constants[12]) - algebraic_variables[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) - algebraic_variables[48] = 1.0*exp(-states[0]/45.0) + algebraic_variables[49] = 14.0/(1.0+exp((-states[0]+40.0)/9.0)) + algebraic_variables[48] = exp(-states[0]/45.0) algebraic_variables[6] = computed_constants[21]*states[14]*(states[0]-computed_constants[4]) if neq_func(constants[1], 2.0) else computed_constants[21]*states[14]*(states[0]-77.6) algebraic_variables[5] = computed_constants[22]*states[14]*(states[0]-computed_constants[6]) if neq_func(constants[1], 2.0) else computed_constants[22]*states[14]*(states[0]+102.0) - algebraic_variables[51] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[1], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) - algebraic_variables[50] = 1.0*exp((states[0]+75.13)/21.25) + algebraic_variables[51] = exp((-states[0]-78.91)/26.62) if eq_func(constants[1], 0.0) else exp((-states[0]-78.91)/26.63) + algebraic_variables[50] = exp((states[0]+75.13)/21.25) diff --git a/tests/resources/generator/global_nla_systems/model.cellml b/tests/resources/generator/global_nla_systems/model.cellml new file mode 100644 index 0000000000..a26dc743ce --- /dev/null +++ b/tests/resources/generator/global_nla_systems/model.cellml @@ -0,0 +1,250 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + t + + q_2 + + v_q_2 + + + + + + + + + t + + x + + + + 1 + 1 + + + + + + + + u_q_2 + + + q_2 + C_q_2 + + + + + + + v_R_1 + + + u_R_1 + R_R_1 + + + + + + + v_R_3 + + + u_R_3 + R_R_3 + + + + + + + v_S_u + + + v_0 + + + + + + + + u_0 + u_S_u + + + + + + u_R_1 + + + u_0 + u_2 + + + + + + + u_R_3 + + + u_2 + u_3 + + + + + + + u_q_2 + u_3 + + + + + + v_1 + + + v_R_1 + x + + + + + + + v_1 + v_0 + + + + + + v_2 + + + v_q_2 + + + t + time + + + + + + + + v_2 + v_3 + + + + + + v_3 + v_R_3 + + + + + + v_3 + v_1 + + + + + + time + t + + + + + + z_0 + + + z_1 + 2 + + + + + + + z_1 + + + z_0 + 1 + + + + + diff --git a/tests/resources/generator/global_nla_systems/model.h b/tests/resources/generator/global_nla_systems/model.h new file mode 100644 index 0000000000..44879a092a --- /dev/null +++ b/tests/resources/generator/global_nla_systems/model.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[6]; + char units[33]; + char component[5]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +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/global_nla_systems/model_linux.c b/tests/resources/generator/global_nla_systems/model_linux.c new file mode 100644 index 0000000000..acdc1ee3f9 --- /dev/null +++ b/tests/resources/generator/global_nla_systems/model_linux.c @@ -0,0 +1,188 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 4; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 16; + +const VariableInfo VOI_INFO = {"t", "second", "main"}; + +const VariableInfo STATE_INFO[] = { + {"q_2", "coulomb", "main"}, + {"x", "dimensionless", "main"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"C_q_2", "coulomb_squared_per_joule", "main"}, + {"R_R_1", "joule_second_per_coulomb_squared", "main"}, + {"R_R_3", "joule_second_per_coulomb_squared", "main"}, + {"u_S_u", "joule_per_coulomb", "main"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"u_0", "joule_per_coulomb", "main"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"v_q_2", "coulomb_per_second", "main"}, + {"u_q_2", "joule_per_coulomb", "main"}, + {"u_R_1", "joule_per_coulomb", "main"}, + {"v_R_1", "coulomb_per_second", "main"}, + {"u_R_3", "joule_per_coulomb", "main"}, + {"v_R_3", "coulomb_per_second", "main"}, + {"v_0", "coulomb_per_second", "main"}, + {"v_S_u", "coulomb_per_second", "main"}, + {"u_2", "joule_per_coulomb", "main"}, + {"u_3", "joule_per_coulomb", "main"}, + {"v_1", "coulomb_per_second", "main"}, + {"time", "second", "main"}, + {"v_2", "coulomb_per_second", "main"}, + {"v_3", "coulomb_per_second", "main"}, + {"z_1", "dimensionless", "main"}, + {"z_0", "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[14] = u[0]; + + f[0] = algebraicVariables[14]-(-1.0+pow(algebraicVariables[14], 2.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[14]; + + nlaSolve(objectiveFunction0, u, 1, &rfi); + + algebraicVariables[14] = u[0]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + states[1] = 0.0; + constants[0] = 4.0; + constants[1] = 4.0; + constants[2] = 4.0; + constants[3] = 12.0; + algebraicVariables[14] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[3]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[11] = voi; + algebraicVariables[1] = states[0]/constants[0]; + algebraicVariables[9] = algebraicVariables[1]; + algebraicVariables[2] = states[1]*algebraicVariables[9]*constants[1]/(-constants[2]-states[1]*constants[1])-states[1]*computedConstants[0]*constants[1]/(-constants[2]-states[1]*constants[1]); + algebraicVariables[3] = algebraicVariables[2]/constants[1]; + algebraicVariables[10] = algebraicVariables[3]/states[1]; + algebraicVariables[13] = algebraicVariables[10]; + algebraicVariables[12] = algebraicVariables[13]; + algebraicVariables[0] = algebraicVariables[12]*algebraicVariables[11]/voi; + rates[0] = algebraicVariables[0]; + rates[1] = 1.0; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[1] = states[0]/constants[0]; + algebraicVariables[9] = algebraicVariables[1]; + algebraicVariables[2] = states[1]*algebraicVariables[9]*constants[1]/(-constants[2]-states[1]*constants[1])-states[1]*computedConstants[0]*constants[1]/(-constants[2]-states[1]*constants[1]); + algebraicVariables[3] = algebraicVariables[2]/constants[1]; + algebraicVariables[8] = computedConstants[0]-algebraicVariables[2]; + algebraicVariables[4] = algebraicVariables[8]-algebraicVariables[9]; + algebraicVariables[5] = algebraicVariables[4]/constants[2]; + algebraicVariables[10] = algebraicVariables[3]/states[1]; + algebraicVariables[6] = algebraicVariables[10]; + algebraicVariables[7] = -algebraicVariables[6]; + algebraicVariables[13] = algebraicVariables[10]; + algebraicVariables[12] = algebraicVariables[13]; + algebraicVariables[0] = algebraicVariables[12]*algebraicVariables[11]/voi; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + algebraicVariables[15] = pow(algebraicVariables[14], 2.0); +} diff --git a/tests/resources/generator/global_nla_systems/model_linux.py b/tests/resources/generator/global_nla_systems/model_linux.py new file mode 100644 index 0000000000..f04ac10792 --- /dev/null +++ b/tests/resources/generator/global_nla_systems/model_linux.py @@ -0,0 +1,138 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 2 +CONSTANT_COUNT = 4 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 16 + +VOI_INFO = {"name": "t", "units": "second", "component": "main"} + +STATE_INFO = [ + {"name": "q_2", "units": "coulomb", "component": "main"}, + {"name": "x", "units": "dimensionless", "component": "main"} +] + +CONSTANT_INFO = [ + {"name": "C_q_2", "units": "coulomb_squared_per_joule", "component": "main"}, + {"name": "R_R_1", "units": "joule_second_per_coulomb_squared", "component": "main"}, + {"name": "R_R_3", "units": "joule_second_per_coulomb_squared", "component": "main"}, + {"name": "u_S_u", "units": "joule_per_coulomb", "component": "main"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "u_0", "units": "joule_per_coulomb", "component": "main"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "v_q_2", "units": "coulomb_per_second", "component": "main"}, + {"name": "u_q_2", "units": "joule_per_coulomb", "component": "main"}, + {"name": "u_R_1", "units": "joule_per_coulomb", "component": "main"}, + {"name": "v_R_1", "units": "coulomb_per_second", "component": "main"}, + {"name": "u_R_3", "units": "joule_per_coulomb", "component": "main"}, + {"name": "v_R_3", "units": "coulomb_per_second", "component": "main"}, + {"name": "v_0", "units": "coulomb_per_second", "component": "main"}, + {"name": "v_S_u", "units": "coulomb_per_second", "component": "main"}, + {"name": "u_2", "units": "joule_per_coulomb", "component": "main"}, + {"name": "u_3", "units": "joule_per_coulomb", "component": "main"}, + {"name": "v_1", "units": "coulomb_per_second", "component": "main"}, + {"name": "time", "units": "second", "component": "main"}, + {"name": "v_2", "units": "coulomb_per_second", "component": "main"}, + {"name": "v_3", "units": "coulomb_per_second", "component": "main"}, + {"name": "z_1", "units": "dimensionless", "component": "main"}, + {"name": "z_0", "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] + + algebraic_variables[14] = u[0] + + f[0] = algebraic_variables[14]-(-1.0+pow(algebraic_variables[14], 2.0)) + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraic_variables[14] + + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraic_variables[14] = u[0] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.0 + constants[0] = 4.0 + constants[1] = 4.0 + constants[2] = 4.0 + constants[3] = 12.0 + algebraic_variables[14] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = constants[3] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[11] = voi + algebraic_variables[1] = states[0]/constants[0] + algebraic_variables[9] = algebraic_variables[1] + algebraic_variables[2] = states[1]*algebraic_variables[9]*constants[1]/(-constants[2]-states[1]*constants[1])-states[1]*computed_constants[0]*constants[1]/(-constants[2]-states[1]*constants[1]) + algebraic_variables[3] = algebraic_variables[2]/constants[1] + algebraic_variables[10] = algebraic_variables[3]/states[1] + algebraic_variables[13] = algebraic_variables[10] + algebraic_variables[12] = algebraic_variables[13] + algebraic_variables[0] = algebraic_variables[12]*algebraic_variables[11]/voi + rates[0] = algebraic_variables[0] + rates[1] = 1.0 + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[1] = states[0]/constants[0] + algebraic_variables[9] = algebraic_variables[1] + algebraic_variables[2] = states[1]*algebraic_variables[9]*constants[1]/(-constants[2]-states[1]*constants[1])-states[1]*computed_constants[0]*constants[1]/(-constants[2]-states[1]*constants[1]) + algebraic_variables[3] = algebraic_variables[2]/constants[1] + algebraic_variables[8] = computed_constants[0]-algebraic_variables[2] + algebraic_variables[4] = algebraic_variables[8]-algebraic_variables[9] + algebraic_variables[5] = algebraic_variables[4]/constants[2] + algebraic_variables[10] = algebraic_variables[3]/states[1] + algebraic_variables[6] = algebraic_variables[10] + algebraic_variables[7] = -algebraic_variables[6] + algebraic_variables[13] = algebraic_variables[10] + algebraic_variables[12] = algebraic_variables[13] + algebraic_variables[0] = algebraic_variables[12]*algebraic_variables[11]/voi + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + algebraic_variables[15] = pow(algebraic_variables[14], 2.0) diff --git a/tests/resources/generator/global_nla_systems/model_macos.c b/tests/resources/generator/global_nla_systems/model_macos.c new file mode 100644 index 0000000000..acdc1ee3f9 --- /dev/null +++ b/tests/resources/generator/global_nla_systems/model_macos.c @@ -0,0 +1,188 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 4; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 16; + +const VariableInfo VOI_INFO = {"t", "second", "main"}; + +const VariableInfo STATE_INFO[] = { + {"q_2", "coulomb", "main"}, + {"x", "dimensionless", "main"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"C_q_2", "coulomb_squared_per_joule", "main"}, + {"R_R_1", "joule_second_per_coulomb_squared", "main"}, + {"R_R_3", "joule_second_per_coulomb_squared", "main"}, + {"u_S_u", "joule_per_coulomb", "main"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"u_0", "joule_per_coulomb", "main"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"v_q_2", "coulomb_per_second", "main"}, + {"u_q_2", "joule_per_coulomb", "main"}, + {"u_R_1", "joule_per_coulomb", "main"}, + {"v_R_1", "coulomb_per_second", "main"}, + {"u_R_3", "joule_per_coulomb", "main"}, + {"v_R_3", "coulomb_per_second", "main"}, + {"v_0", "coulomb_per_second", "main"}, + {"v_S_u", "coulomb_per_second", "main"}, + {"u_2", "joule_per_coulomb", "main"}, + {"u_3", "joule_per_coulomb", "main"}, + {"v_1", "coulomb_per_second", "main"}, + {"time", "second", "main"}, + {"v_2", "coulomb_per_second", "main"}, + {"v_3", "coulomb_per_second", "main"}, + {"z_1", "dimensionless", "main"}, + {"z_0", "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[14] = u[0]; + + f[0] = algebraicVariables[14]-(-1.0+pow(algebraicVariables[14], 2.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[14]; + + nlaSolve(objectiveFunction0, u, 1, &rfi); + + algebraicVariables[14] = u[0]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + states[1] = 0.0; + constants[0] = 4.0; + constants[1] = 4.0; + constants[2] = 4.0; + constants[3] = 12.0; + algebraicVariables[14] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[3]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[11] = voi; + algebraicVariables[1] = states[0]/constants[0]; + algebraicVariables[9] = algebraicVariables[1]; + algebraicVariables[2] = states[1]*algebraicVariables[9]*constants[1]/(-constants[2]-states[1]*constants[1])-states[1]*computedConstants[0]*constants[1]/(-constants[2]-states[1]*constants[1]); + algebraicVariables[3] = algebraicVariables[2]/constants[1]; + algebraicVariables[10] = algebraicVariables[3]/states[1]; + algebraicVariables[13] = algebraicVariables[10]; + algebraicVariables[12] = algebraicVariables[13]; + algebraicVariables[0] = algebraicVariables[12]*algebraicVariables[11]/voi; + rates[0] = algebraicVariables[0]; + rates[1] = 1.0; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[1] = states[0]/constants[0]; + algebraicVariables[9] = algebraicVariables[1]; + algebraicVariables[2] = states[1]*algebraicVariables[9]*constants[1]/(-constants[2]-states[1]*constants[1])-states[1]*computedConstants[0]*constants[1]/(-constants[2]-states[1]*constants[1]); + algebraicVariables[3] = algebraicVariables[2]/constants[1]; + algebraicVariables[8] = computedConstants[0]-algebraicVariables[2]; + algebraicVariables[4] = algebraicVariables[8]-algebraicVariables[9]; + algebraicVariables[5] = algebraicVariables[4]/constants[2]; + algebraicVariables[10] = algebraicVariables[3]/states[1]; + algebraicVariables[6] = algebraicVariables[10]; + algebraicVariables[7] = -algebraicVariables[6]; + algebraicVariables[13] = algebraicVariables[10]; + algebraicVariables[12] = algebraicVariables[13]; + algebraicVariables[0] = algebraicVariables[12]*algebraicVariables[11]/voi; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + algebraicVariables[15] = pow(algebraicVariables[14], 2.0); +} diff --git a/tests/resources/generator/global_nla_systems/model_macos.py b/tests/resources/generator/global_nla_systems/model_macos.py new file mode 100644 index 0000000000..f04ac10792 --- /dev/null +++ b/tests/resources/generator/global_nla_systems/model_macos.py @@ -0,0 +1,138 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 2 +CONSTANT_COUNT = 4 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 16 + +VOI_INFO = {"name": "t", "units": "second", "component": "main"} + +STATE_INFO = [ + {"name": "q_2", "units": "coulomb", "component": "main"}, + {"name": "x", "units": "dimensionless", "component": "main"} +] + +CONSTANT_INFO = [ + {"name": "C_q_2", "units": "coulomb_squared_per_joule", "component": "main"}, + {"name": "R_R_1", "units": "joule_second_per_coulomb_squared", "component": "main"}, + {"name": "R_R_3", "units": "joule_second_per_coulomb_squared", "component": "main"}, + {"name": "u_S_u", "units": "joule_per_coulomb", "component": "main"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "u_0", "units": "joule_per_coulomb", "component": "main"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "v_q_2", "units": "coulomb_per_second", "component": "main"}, + {"name": "u_q_2", "units": "joule_per_coulomb", "component": "main"}, + {"name": "u_R_1", "units": "joule_per_coulomb", "component": "main"}, + {"name": "v_R_1", "units": "coulomb_per_second", "component": "main"}, + {"name": "u_R_3", "units": "joule_per_coulomb", "component": "main"}, + {"name": "v_R_3", "units": "coulomb_per_second", "component": "main"}, + {"name": "v_0", "units": "coulomb_per_second", "component": "main"}, + {"name": "v_S_u", "units": "coulomb_per_second", "component": "main"}, + {"name": "u_2", "units": "joule_per_coulomb", "component": "main"}, + {"name": "u_3", "units": "joule_per_coulomb", "component": "main"}, + {"name": "v_1", "units": "coulomb_per_second", "component": "main"}, + {"name": "time", "units": "second", "component": "main"}, + {"name": "v_2", "units": "coulomb_per_second", "component": "main"}, + {"name": "v_3", "units": "coulomb_per_second", "component": "main"}, + {"name": "z_1", "units": "dimensionless", "component": "main"}, + {"name": "z_0", "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] + + algebraic_variables[14] = u[0] + + f[0] = algebraic_variables[14]-(-1.0+pow(algebraic_variables[14], 2.0)) + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraic_variables[14] + + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraic_variables[14] = u[0] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.0 + constants[0] = 4.0 + constants[1] = 4.0 + constants[2] = 4.0 + constants[3] = 12.0 + algebraic_variables[14] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = constants[3] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[11] = voi + algebraic_variables[1] = states[0]/constants[0] + algebraic_variables[9] = algebraic_variables[1] + algebraic_variables[2] = states[1]*algebraic_variables[9]*constants[1]/(-constants[2]-states[1]*constants[1])-states[1]*computed_constants[0]*constants[1]/(-constants[2]-states[1]*constants[1]) + algebraic_variables[3] = algebraic_variables[2]/constants[1] + algebraic_variables[10] = algebraic_variables[3]/states[1] + algebraic_variables[13] = algebraic_variables[10] + algebraic_variables[12] = algebraic_variables[13] + algebraic_variables[0] = algebraic_variables[12]*algebraic_variables[11]/voi + rates[0] = algebraic_variables[0] + rates[1] = 1.0 + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[1] = states[0]/constants[0] + algebraic_variables[9] = algebraic_variables[1] + algebraic_variables[2] = states[1]*algebraic_variables[9]*constants[1]/(-constants[2]-states[1]*constants[1])-states[1]*computed_constants[0]*constants[1]/(-constants[2]-states[1]*constants[1]) + algebraic_variables[3] = algebraic_variables[2]/constants[1] + algebraic_variables[8] = computed_constants[0]-algebraic_variables[2] + algebraic_variables[4] = algebraic_variables[8]-algebraic_variables[9] + algebraic_variables[5] = algebraic_variables[4]/constants[2] + algebraic_variables[10] = algebraic_variables[3]/states[1] + algebraic_variables[6] = algebraic_variables[10] + algebraic_variables[7] = -algebraic_variables[6] + algebraic_variables[13] = algebraic_variables[10] + algebraic_variables[12] = algebraic_variables[13] + algebraic_variables[0] = algebraic_variables[12]*algebraic_variables[11]/voi + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + algebraic_variables[15] = pow(algebraic_variables[14], 2.0) diff --git a/tests/resources/generator/global_nla_systems/model_windows.c b/tests/resources/generator/global_nla_systems/model_windows.c new file mode 100644 index 0000000000..829aed0d7c --- /dev/null +++ b/tests/resources/generator/global_nla_systems/model_windows.c @@ -0,0 +1,188 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 4; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 16; + +const VariableInfo VOI_INFO = {"t", "second", "main"}; + +const VariableInfo STATE_INFO[] = { + {"q_2", "coulomb", "main"}, + {"x", "dimensionless", "main"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"C_q_2", "coulomb_squared_per_joule", "main"}, + {"R_R_1", "joule_second_per_coulomb_squared", "main"}, + {"R_R_3", "joule_second_per_coulomb_squared", "main"}, + {"u_S_u", "joule_per_coulomb", "main"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"u_0", "joule_per_coulomb", "main"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"v_q_2", "coulomb_per_second", "main"}, + {"u_q_2", "joule_per_coulomb", "main"}, + {"u_R_1", "joule_per_coulomb", "main"}, + {"v_R_1", "coulomb_per_second", "main"}, + {"u_R_3", "joule_per_coulomb", "main"}, + {"v_R_3", "coulomb_per_second", "main"}, + {"v_0", "coulomb_per_second", "main"}, + {"v_S_u", "coulomb_per_second", "main"}, + {"u_2", "joule_per_coulomb", "main"}, + {"u_3", "joule_per_coulomb", "main"}, + {"v_1", "coulomb_per_second", "main"}, + {"time", "second", "main"}, + {"v_2", "coulomb_per_second", "main"}, + {"v_3", "coulomb_per_second", "main"}, + {"z_1", "dimensionless", "main"}, + {"z_0", "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[14] = u[0]; + + f[0] = algebraicVariables[14]-(-1.0+pow(algebraicVariables[14], 2.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[14]; + + nlaSolve(objectiveFunction0, u, 1, &rfi); + + algebraicVariables[14] = u[0]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + states[1] = 0.0; + constants[0] = 4.0; + constants[1] = 4.0; + constants[2] = 4.0; + constants[3] = 12.0; + algebraicVariables[14] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[3]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[11] = voi; + algebraicVariables[1] = states[0]/constants[0]; + algebraicVariables[9] = algebraicVariables[1]; + algebraicVariables[2] = -states[1]*computedConstants[0]*constants[1]/(-constants[2]-states[1]*constants[1])+states[1]*algebraicVariables[9]*constants[1]/(-constants[2]-states[1]*constants[1]); + algebraicVariables[3] = algebraicVariables[2]/constants[1]; + algebraicVariables[10] = algebraicVariables[3]/states[1]; + algebraicVariables[13] = algebraicVariables[10]; + algebraicVariables[12] = algebraicVariables[13]; + algebraicVariables[0] = algebraicVariables[12]*algebraicVariables[11]/voi; + rates[0] = algebraicVariables[0]; + rates[1] = 1.0; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[1] = states[0]/constants[0]; + algebraicVariables[9] = algebraicVariables[1]; + algebraicVariables[2] = -states[1]*computedConstants[0]*constants[1]/(-constants[2]-states[1]*constants[1])+states[1]*algebraicVariables[9]*constants[1]/(-constants[2]-states[1]*constants[1]); + algebraicVariables[3] = algebraicVariables[2]/constants[1]; + algebraicVariables[8] = -algebraicVariables[2]+computedConstants[0]; + algebraicVariables[4] = algebraicVariables[8]-algebraicVariables[9]; + algebraicVariables[5] = algebraicVariables[4]/constants[2]; + algebraicVariables[10] = algebraicVariables[3]/states[1]; + algebraicVariables[6] = algebraicVariables[10]; + algebraicVariables[7] = -algebraicVariables[6]; + algebraicVariables[13] = algebraicVariables[10]; + algebraicVariables[12] = algebraicVariables[13]; + algebraicVariables[0] = algebraicVariables[12]*algebraicVariables[11]/voi; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + algebraicVariables[15] = pow(algebraicVariables[14], 2.0); +} diff --git a/tests/resources/generator/global_nla_systems/model_windows.py b/tests/resources/generator/global_nla_systems/model_windows.py new file mode 100644 index 0000000000..1f16a86530 --- /dev/null +++ b/tests/resources/generator/global_nla_systems/model_windows.py @@ -0,0 +1,138 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 2 +CONSTANT_COUNT = 4 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 16 + +VOI_INFO = {"name": "t", "units": "second", "component": "main"} + +STATE_INFO = [ + {"name": "q_2", "units": "coulomb", "component": "main"}, + {"name": "x", "units": "dimensionless", "component": "main"} +] + +CONSTANT_INFO = [ + {"name": "C_q_2", "units": "coulomb_squared_per_joule", "component": "main"}, + {"name": "R_R_1", "units": "joule_second_per_coulomb_squared", "component": "main"}, + {"name": "R_R_3", "units": "joule_second_per_coulomb_squared", "component": "main"}, + {"name": "u_S_u", "units": "joule_per_coulomb", "component": "main"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "u_0", "units": "joule_per_coulomb", "component": "main"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "v_q_2", "units": "coulomb_per_second", "component": "main"}, + {"name": "u_q_2", "units": "joule_per_coulomb", "component": "main"}, + {"name": "u_R_1", "units": "joule_per_coulomb", "component": "main"}, + {"name": "v_R_1", "units": "coulomb_per_second", "component": "main"}, + {"name": "u_R_3", "units": "joule_per_coulomb", "component": "main"}, + {"name": "v_R_3", "units": "coulomb_per_second", "component": "main"}, + {"name": "v_0", "units": "coulomb_per_second", "component": "main"}, + {"name": "v_S_u", "units": "coulomb_per_second", "component": "main"}, + {"name": "u_2", "units": "joule_per_coulomb", "component": "main"}, + {"name": "u_3", "units": "joule_per_coulomb", "component": "main"}, + {"name": "v_1", "units": "coulomb_per_second", "component": "main"}, + {"name": "time", "units": "second", "component": "main"}, + {"name": "v_2", "units": "coulomb_per_second", "component": "main"}, + {"name": "v_3", "units": "coulomb_per_second", "component": "main"}, + {"name": "z_1", "units": "dimensionless", "component": "main"}, + {"name": "z_0", "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] + + algebraic_variables[14] = u[0] + + f[0] = algebraic_variables[14]-(-1.0+pow(algebraic_variables[14], 2.0)) + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraic_variables[14] + + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraic_variables[14] = u[0] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.0 + constants[0] = 4.0 + constants[1] = 4.0 + constants[2] = 4.0 + constants[3] = 12.0 + algebraic_variables[14] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = constants[3] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[11] = voi + algebraic_variables[1] = states[0]/constants[0] + algebraic_variables[9] = algebraic_variables[1] + algebraic_variables[2] = -states[1]*computed_constants[0]*constants[1]/(-constants[2]-states[1]*constants[1])+states[1]*algebraic_variables[9]*constants[1]/(-constants[2]-states[1]*constants[1]) + algebraic_variables[3] = algebraic_variables[2]/constants[1] + algebraic_variables[10] = algebraic_variables[3]/states[1] + algebraic_variables[13] = algebraic_variables[10] + algebraic_variables[12] = algebraic_variables[13] + algebraic_variables[0] = algebraic_variables[12]*algebraic_variables[11]/voi + rates[0] = algebraic_variables[0] + rates[1] = 1.0 + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[1] = states[0]/constants[0] + algebraic_variables[9] = algebraic_variables[1] + algebraic_variables[2] = -states[1]*computed_constants[0]*constants[1]/(-constants[2]-states[1]*constants[1])+states[1]*algebraic_variables[9]*constants[1]/(-constants[2]-states[1]*constants[1]) + algebraic_variables[3] = algebraic_variables[2]/constants[1] + algebraic_variables[8] = -algebraic_variables[2]+computed_constants[0] + algebraic_variables[4] = algebraic_variables[8]-algebraic_variables[9] + algebraic_variables[5] = algebraic_variables[4]/constants[2] + algebraic_variables[10] = algebraic_variables[3]/states[1] + algebraic_variables[6] = algebraic_variables[10] + algebraic_variables[7] = -algebraic_variables[6] + algebraic_variables[13] = algebraic_variables[10] + algebraic_variables[12] = algebraic_variables[13] + algebraic_variables[0] = algebraic_variables[12]*algebraic_variables[11]/voi + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + algebraic_variables[15] = pow(algebraic_variables[14], 2.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index d3dd82185e..1c7f31719e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -135,11 +135,11 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); algebraicVariables[0] = constants[2]*(states[0]-computedConstants[0]); algebraicVariables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraicVariables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-externalVariables[0]+algebraicVariables[2]+algebraicVariables[1]+algebraicVariables[0])/constants[0]; + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + rates[0] = (externalVariables[0]-algebraicVariables[2]-algebraicVariables[1]-algebraicVariables[0])/constants[0]; algebraicVariables[4] = 4.0*exp(states[0]/18.0); algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraicVariables[3]*(1.0-states[2])-algebraicVariables[4]*states[2]; 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 edce82aef5..5405b8a565 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -104,11 +104,11 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) algebraic_variables[0] = constants[2]*(states[0]-computed_constants[0]) algebraic_variables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic_variables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-external_variables[0]+algebraic_variables[2]+algebraic_variables[1]+algebraic_variables[0])/constants[0] + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + rates[0] = (external_variables[0]-algebraic_variables[2]-algebraic_variables[1]-algebraic_variables[0])/constants[0] algebraic_variables[4] = 4.0*exp(states[0]/18.0) algebraic_variables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic_variables[3]*(1.0-states[2])-algebraic_variables[4]*states[2] 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 d1d300dc9a..5c4e32734b 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 @@ -120,11 +120,11 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; algebraicVariables[1] = constants[2]*(states[0]-computedConstants[0]); algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[3]-algebraicVariables[2]-algebraicVariables[1])/constants[0]; algebraicVariables[5] = 4.0*exp(states[0]/18.0); algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2]; 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 db4551c51e..653401572c 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 @@ -134,12 +134,12 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); algebraicVariables[1] = constants[2]*(states[0]-externalVariables[0]); algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); - rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[3]-algebraicVariables[2]-algebraicVariables[1])/constants[0]; algebraicVariables[5] = 4.0*exp(states[0]/18.0); algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2]; 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 41aa825d49..f5c92da25b 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 @@ -103,12 +103,12 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) algebraic_variables[1] = constants[2]*(states[0]-external_variables[0]) algebraic_variables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) algebraic_variables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) - rates[0] = -(-algebraic_variables[0]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1])/constants[0] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[3]-algebraic_variables[2]-algebraic_variables[1])/constants[0] algebraic_variables[5] = 4.0*exp(states[0]/18.0) algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic_variables[4]*(1.0-states[2])-algebraic_variables[5]*states[2] 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 4a296abf8b..6699e58587 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -135,11 +135,11 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; algebraicVariables[1] = constants[1]*(states[0]-computedConstants[0]); algebraicVariables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraicVariables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/externalVariables[0]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[3]-algebraicVariables[2]-algebraicVariables[1])/externalVariables[0]; algebraicVariables[5] = 4.0*exp(states[0]/18.0); algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2]; 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 a71adc1193..461fdf34b2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -104,11 +104,11 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 algebraic_variables[1] = constants[1]*(states[0]-computed_constants[0]) algebraic_variables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic_variables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic_variables[0]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1])/external_variables[0] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[3]-algebraic_variables[2]-algebraic_variables[1])/external_variables[0] algebraic_variables[5] = 4.0*exp(states[0]/18.0) algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic_variables[4]*(1.0-states[2])-algebraic_variables[5]*states[2] 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 deleted file mode 100644 index fb3faaaf85..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ /dev/null @@ -1,625 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.7.0. */ - -#include "model.dae.h" - -#include -#include - -const char VERSION[] = "0.8.0"; -const char LIBCELLML_VERSION[] = "0.7.0"; - -const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 5; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_VARIABLE_COUNT = 13; - -const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; - -const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane"}, - {"h", "dimensionless", "sodium_channel_h_gate"}, - {"m", "dimensionless", "sodium_channel_m_gate"}, - {"n", "dimensionless", "potassium_channel_n_gate"} -}; - -const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane"}, - {"E_R", "millivolt", "membrane"}, - {"g_L", "milliS_per_cm2", "leakage_current"}, - {"g_Na", "milliS_per_cm2", "sodium_channel"}, - {"g_K", "milliS_per_cm2", "potassium_channel"} -}; - -const VariableInfo COMPUTED_CONSTANT_INFO[] = { -}; - -const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane"}, - {"i_L", "microA_per_cm2", "leakage_current"}, - {"i_K", "microA_per_cm2", "potassium_channel"}, - {"i_Na", "microA_per_cm2", "sodium_channel"}, - {"E_L", "millivolt", "leakage_current"}, - {"E_Na", "millivolt", "sodium_channel"}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, - {"E_K", "millivolt", "potassium_channel"}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate"} -}; - -double * createStatesArray() -{ - double *res = (double *) malloc(STATE_COUNT*sizeof(double)); - - for (size_t i = 0; i < STATE_COUNT; ++i) { - res[i] = NAN; - } - - return res; -} - -double * createConstantsArray() -{ - double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - - for (size_t i = 0; i < CONSTANT_COUNT; ++i) { - res[i] = NAN; - } - - return res; -} - -double * createComputedConstantsArray() -{ - double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); - - for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { - res[i] = NAN; - } - - return res; -} - -double * 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] = algebraicVariables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; -} - -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *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; - - rates[0] = u[0]; - - f[0] = rates[0]-(-(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0])-0.0; -} - -void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = rates[0]; - - nlaSolve(objectiveFunction1, u, 1, &rfi); - - rates[0] = u[0]; -} - -void objectiveFunction2(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[4] = u[0]; - - f[0] = algebraicVariables[4]-(constants[1]-10.613)-0.0; -} - -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[4]; - - nlaSolve(objectiveFunction2, u, 1, &rfi); - - algebraicVariables[4] = 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[1] = u[0]; - - f[0] = algebraicVariables[1]-constants[2]*(states[0]-algebraicVariables[4])-0.0; -} - -void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[1]; - - nlaSolve(objectiveFunction3, u, 1, &rfi); - - algebraicVariables[1] = u[0]; -} - -void objectiveFunction4(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[5] = u[0]; - - f[0] = algebraicVariables[5]-(constants[1]-115.0)-0.0; -} - -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[5]; - - nlaSolve(objectiveFunction4, u, 1, &rfi); - - algebraicVariables[5] = 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[3] = u[0]; - - f[0] = algebraicVariables[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraicVariables[5])-0.0; -} - -void findRoot5(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[3]; - - nlaSolve(objectiveFunction5, u, 1, &rfi); - - algebraicVariables[3] = 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] = algebraicVariables[6]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0; -} - -void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *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] = algebraicVariables[7]-4.0*exp(states[0]/18.0)-0.0; -} - -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; - - rates[2] = u[0]; - - f[0] = rates[2]-(algebraicVariables[6]*(1.0-states[2])-algebraicVariables[7]*states[2])-0.0; -} - -void findRoot8(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = rates[2]; - - nlaSolve(objectiveFunction8, u, 1, &rfi); - - rates[2] = 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[8] = u[0]; - - f[0] = algebraicVariables[8]-0.07*exp(states[0]/20.0)-0.0; -} - -void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[8]; - - nlaSolve(objectiveFunction9, u, 1, &rfi); - - algebraicVariables[8] = 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[9] = u[0]; - - f[0] = algebraicVariables[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; -} - -void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[9]; - - nlaSolve(objectiveFunction10, u, 1, &rfi); - - algebraicVariables[9] = 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; - - rates[1] = u[0]; - - f[0] = rates[1]-(algebraicVariables[8]*(1.0-states[1])-algebraicVariables[9]*states[1])-0.0; -} - -void findRoot11(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = rates[1]; - - nlaSolve(objectiveFunction11, u, 1, &rfi); - - rates[1] = 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[10] = u[0]; - - f[0] = algebraicVariables[10]-(constants[1]+12.0)-0.0; -} - -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[10]; - - nlaSolve(objectiveFunction12, u, 1, &rfi); - - algebraicVariables[10] = 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[2] = u[0]; - - f[0] = algebraicVariables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-algebraicVariables[10])-0.0; -} - -void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[2]; - - nlaSolve(objectiveFunction13, u, 1, &rfi); - - algebraicVariables[2] = 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[11] = u[0]; - - f[0] = algebraicVariables[11]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; -} - -void findRoot14(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[11]; - - nlaSolve(objectiveFunction14, u, 1, &rfi); - - algebraicVariables[11] = 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[12] = u[0]; - - f[0] = algebraicVariables[12]-0.125*exp(states[0]/80.0)-0.0; -} - -void findRoot15(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[12]; - - nlaSolve(objectiveFunction15, u, 1, &rfi); - - algebraicVariables[12] = 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; - - rates[3] = u[0]; - - f[0] = rates[3]-(algebraicVariables[11]*(1.0-states[3])-algebraicVariables[12]*states[3])-0.0; -} - -void findRoot16(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = rates[3]; - - nlaSolve(objectiveFunction16, u, 1, &rfi); - - rates[3] = u[0]; -} - -void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; - rates[0] = 0.0; - rates[1] = 0.0; - rates[2] = 0.0; - rates[3] = 0.0; - constants[0] = 1.0; - constants[1] = 0.0; - constants[2] = 0.3; - constants[3] = 120.0; - constants[4] = 36.0; - algebraicVariables[0] = 0.0; - algebraicVariables[1] = 0.0; - algebraicVariables[2] = 0.0; - algebraicVariables[3] = 0.0; - algebraicVariables[4] = 0.0; - algebraicVariables[5] = 0.0; - algebraicVariables[6] = 0.0; - algebraicVariables[7] = 0.0; - algebraicVariables[8] = 0.0; - algebraicVariables[9] = 0.0; - algebraicVariables[10] = 0.0; - algebraicVariables[11] = 0.0; - algebraicVariables[12] = 0.0; -} - -void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ -} - -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot15(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot16(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); -} - -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot15(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot16(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); -} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c deleted file mode 100644 index 5e33e7b3d0..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c +++ /dev/null @@ -1,562 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.7.0. */ - -#include "model.dae.external.h" - -#include -#include - -const char VERSION[] = "0.8.0"; -const char LIBCELLML_VERSION[] = "0.7.0"; - -const size_t STATE_COUNT = 3; -const size_t CONSTANT_COUNT = 5; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_VARIABLE_COUNT = 11; -const size_t EXTERNAL_VARIABLE_COUNT = 3; - -const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; - -const VariableInfo STATE_INFO[] = { - {"h", "dimensionless", "sodium_channel_h_gate"}, - {"m", "dimensionless", "sodium_channel_m_gate"}, - {"n", "dimensionless", "potassium_channel_n_gate"} -}; - -const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane"}, - {"E_R", "millivolt", "membrane"}, - {"g_L", "milliS_per_cm2", "leakage_current"}, - {"g_Na", "milliS_per_cm2", "sodium_channel"}, - {"g_K", "milliS_per_cm2", "potassium_channel"} -}; - -const VariableInfo COMPUTED_CONSTANT_INFO[] = { -}; - -const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane"}, - {"i_L", "microA_per_cm2", "leakage_current"}, - {"i_K", "microA_per_cm2", "potassium_channel"}, - {"E_L", "millivolt", "leakage_current"}, - {"E_Na", "millivolt", "sodium_channel"}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, - {"E_K", "millivolt", "potassium_channel"}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate"} -}; - -const VariableInfo EXTERNAL_VARIABLE_INFO[] = { - {"i_Na", "microA_per_cm2", "sodium_channel"}, - {"V", "millivolt", "membrane"}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate"} -}; - -double * createStatesArray() -{ - double *res = (double *) malloc(STATE_COUNT*sizeof(double)); - - for (size_t i = 0; i < STATE_COUNT; ++i) { - res[i] = NAN; - } - - return res; -} - -double * createConstantsArray() -{ - double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - - for (size_t i = 0; i < CONSTANT_COUNT; ++i) { - res[i] = NAN; - } - - return res; -} - -double * createComputedConstantsArray() -{ - double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); - - for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { - res[i] = NAN; - } - - return res; -} - -double * 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; -} - -double * createExternalVariablesArray() -{ - double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - - for (size_t i = 0; i < EXTERNAL_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; - double *externalVariables; -} 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[0] = u[0]; - - f[0] = algebraicVariables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; -} - -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[0]; - - nlaSolve(objectiveFunction0, u, 1, &rfi); - - algebraicVariables[0] = u[0]; -} - -void objectiveFunction2(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[3] = u[0]; - - f[0] = algebraicVariables[3]-(constants[1]-10.613)-0.0; -} - -void findRoot2(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[3]; - - nlaSolve(objectiveFunction2, u, 1, &rfi); - - algebraicVariables[3] = u[0]; -} - -void objectiveFunction3(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[1] = u[0]; - - f[0] = algebraicVariables[1]-constants[2]*(externalVariables[1]-algebraicVariables[3])-0.0; -} - -void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[1]; - - nlaSolve(objectiveFunction3, u, 1, &rfi); - - algebraicVariables[1] = u[0]; -} - -void objectiveFunction4(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[4] = u[0]; - - f[0] = algebraicVariables[4]-(constants[1]-115.0)-0.0; -} - -void findRoot4(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[4]; - - nlaSolve(objectiveFunction4, u, 1, &rfi); - - algebraicVariables[4] = u[0]; -} - -void objectiveFunction6(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[5] = u[0]; - - f[0] = algebraicVariables[5]-0.1*(externalVariables[1]+25.0)/(exp((externalVariables[1]+25.0)/10.0)-1.0)-0.0; -} - -void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[5]; - - nlaSolve(objectiveFunction6, u, 1, &rfi); - - algebraicVariables[5] = u[0]; -} - -void objectiveFunction7(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[6] = u[0]; - - f[0] = algebraicVariables[6]-4.0*exp(externalVariables[1]/18.0)-0.0; -} - -void findRoot7(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[6]; - - nlaSolve(objectiveFunction7, u, 1, &rfi); - - algebraicVariables[6] = u[0]; -} - -void objectiveFunction8(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[1] = u[0]; - - f[0] = rates[1]-(algebraicVariables[5]*(1.0-states[1])-algebraicVariables[6]*states[1])-0.0; -} - -void findRoot8(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[1]; - - nlaSolve(objectiveFunction8, u, 1, &rfi); - - rates[1] = u[0]; -} - -void objectiveFunction9(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[7] = u[0]; - - f[0] = algebraicVariables[7]-0.07*exp(externalVariables[1]/20.0)-0.0; -} - -void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[7]; - - nlaSolve(objectiveFunction9, u, 1, &rfi); - - algebraicVariables[7] = u[0]; -} - -void objectiveFunction10(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[8] = u[0]; - - f[0] = algebraicVariables[8]-1.0/(exp((externalVariables[1]+30.0)/10.0)+1.0)-0.0; -} - -void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[8]; - - nlaSolve(objectiveFunction10, u, 1, &rfi); - - algebraicVariables[8] = u[0]; -} - -void objectiveFunction11(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[0] = u[0]; - - f[0] = rates[0]-(algebraicVariables[7]*(1.0-states[0])-algebraicVariables[8]*states[0])-0.0; -} - -void findRoot11(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[0]; - - nlaSolve(objectiveFunction11, u, 1, &rfi); - - rates[0] = u[0]; -} - -void objectiveFunction12(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[9] = u[0]; - - f[0] = algebraicVariables[9]-(constants[1]+12.0)-0.0; -} - -void findRoot12(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[9]; - - nlaSolve(objectiveFunction12, u, 1, &rfi); - - algebraicVariables[9] = u[0]; -} - -void objectiveFunction13(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[2] = u[0]; - - f[0] = algebraicVariables[2]-constants[4]*pow(states[2], 4.0)*(externalVariables[1]-algebraicVariables[9])-0.0; -} - -void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[2]; - - nlaSolve(objectiveFunction13, u, 1, &rfi); - - algebraicVariables[2] = u[0]; -} - -void objectiveFunction15(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[10] = u[0]; - - f[0] = algebraicVariables[10]-0.125*exp(externalVariables[1]/80.0)-0.0; -} - -void findRoot15(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[10]; - - nlaSolve(objectiveFunction15, u, 1, &rfi); - - algebraicVariables[10] = u[0]; -} - -void objectiveFunction16(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[2] = u[0]; - - f[0] = rates[2]-(externalVariables[2]*(1.0-states[2])-algebraicVariables[10]*states[2])-0.0; -} - -void findRoot16(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[2]; - - nlaSolve(objectiveFunction16, u, 1, &rfi); - - rates[2] = u[0]; -} - -void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - states[0] = 0.6; - states[1] = 0.05; - states[2] = 0.325; - rates[0] = 0.0; - rates[1] = 0.0; - rates[2] = 0.0; - constants[0] = 1.0; - constants[1] = 0.0; - constants[2] = 0.3; - constants[3] = 120.0; - constants[4] = 36.0; - algebraicVariables[0] = 0.0; - algebraicVariables[1] = 0.0; - algebraicVariables[2] = 0.0; - algebraicVariables[3] = 0.0; - algebraicVariables[4] = 0.0; - algebraicVariables[5] = 0.0; - algebraicVariables[6] = 0.0; - algebraicVariables[7] = 0.0; - algebraicVariables[8] = 0.0; - algebraicVariables[9] = 0.0; - algebraicVariables[10] = 0.0; -} - -void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ -} - -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) -{ - externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot15(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - externalVariables[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 2); - findRoot16(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); -} - -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) -{ - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - externalVariables[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 2); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); -} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py deleted file mode 100644 index 9a5b0e983a..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py +++ /dev/null @@ -1,478 +0,0 @@ -# The content of this file was generated using the Python profile of libCellML 0.7.0. - -from enum import Enum -from math import * - - -__version__ = "0.8.0" -LIBCELLML_VERSION = "0.7.0" - -STATE_COUNT = 3 -CONSTANT_COUNT = 5 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_VARIABLE_COUNT = 11 -EXTERNAL_VARIABLE_COUNT = 3 - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} - -STATE_INFO = [ - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} -] - -CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, - {"name": "E_R", "units": "millivolt", "component": "membrane"}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} -] - -COMPUTED_CONSTANT_INFO = [ -] - -ALGEBRAIC_VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel"}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} -] - -EXTERNAL_VARIABLE_INFO = [ - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, - {"name": "V", "units": "millivolt", "component": "membrane"}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} -] - - -def leq_func(x, y): - return 1.0 if x <= y else 0.0 - - -def geq_func(x, y): - return 1.0 if x >= y else 0.0 - - -def and_func(x, y): - return 1.0 if bool(x) & bool(y) else 0.0 - - -def create_states_array(): - return [nan]*STATE_COUNT - - -def create_constants_array(): - return [nan]*CONSTANT_COUNT - - -def create_computed_constants_array(): - return [nan]*COMPUTED_CONSTANT_COUNT - - -def create_algebraic_variables_array(): - return [nan]*ALGEBRAIC_VARIABLE_COUNT - - -def create_external_variables_array(): - return [nan]*EXTERNAL_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] - external_variables = data[6] - - algebraic_variables[0] = u[0] - - f[0] = algebraic_variables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[0] = u[0] - - -def objective_function_2(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[3] = u[0] - - f[0] = algebraic_variables[3]-(constants[1]-10.613)-0.0 - - -def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[3] - - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[3] = u[0] - - -def objective_function_3(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[1] = u[0] - - f[0] = algebraic_variables[1]-constants[2]*(external_variables[1]-algebraic_variables[3])-0.0 - - -def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[1] - - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[1] = u[0] - - -def objective_function_4(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[4] = u[0] - - f[0] = algebraic_variables[4]-(constants[1]-115.0)-0.0 - - -def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[4] - - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[4] = u[0] - - -def objective_function_6(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[5] = u[0] - - f[0] = algebraic_variables[5]-0.1*(external_variables[1]+25.0)/(exp((external_variables[1]+25.0)/10.0)-1.0)-0.0 - - -def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[5] - - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[5] = u[0] - - -def objective_function_7(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[6] = u[0] - - f[0] = algebraic_variables[6]-4.0*exp(external_variables[1]/18.0)-0.0 - - -def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[6] - - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[6] = u[0] - - -def objective_function_8(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - rates[1] = u[0] - - f[0] = rates[1]-(algebraic_variables[5]*(1.0-states[1])-algebraic_variables[6]*states[1])-0.0 - - -def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[1] - - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[1] = u[0] - - -def objective_function_9(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[7] = u[0] - - f[0] = algebraic_variables[7]-0.07*exp(external_variables[1]/20.0)-0.0 - - -def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[7] - - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[7] = u[0] - - -def objective_function_10(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[8] = u[0] - - f[0] = algebraic_variables[8]-1.0/(exp((external_variables[1]+30.0)/10.0)+1.0)-0.0 - - -def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[8] - - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[8] = u[0] - - -def objective_function_11(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - rates[0] = u[0] - - f[0] = rates[0]-(algebraic_variables[7]*(1.0-states[0])-algebraic_variables[8]*states[0])-0.0 - - -def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[0] - - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[0] = u[0] - - -def objective_function_12(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[9] = u[0] - - f[0] = algebraic_variables[9]-(constants[1]+12.0)-0.0 - - -def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[9] - - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[9] = u[0] - - -def objective_function_13(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[2] = u[0] - - f[0] = algebraic_variables[2]-constants[4]*pow(states[2], 4.0)*(external_variables[1]-algebraic_variables[9])-0.0 - - -def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[2] - - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[2] = u[0] - - -def objective_function_15(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[10] = u[0] - - f[0] = algebraic_variables[10]-0.125*exp(external_variables[1]/80.0)-0.0 - - -def find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[10] - - u = nla_solve(objective_function_15, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[10] = u[0] - - -def objective_function_16(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - rates[2] = u[0] - - f[0] = rates[2]-(external_variables[2]*(1.0-states[2])-algebraic_variables[10]*states[2])-0.0 - - -def find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[2] - - u = nla_solve(objective_function_16, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[2] = u[0] - - -def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): - states[0] = 0.6 - states[1] = 0.05 - states[2] = 0.325 - rates[0] = 0.0 - rates[1] = 0.0 - rates[2] = 0.0 - constants[0] = 1.0 - constants[1] = 0.0 - constants[2] = 0.3 - constants[3] = 120.0 - constants[4] = 36.0 - algebraic_variables[0] = 0.0 - algebraic_variables[1] = 0.0 - algebraic_variables[2] = 0.0 - algebraic_variables[3] = 0.0 - algebraic_variables[4] = 0.0 - algebraic_variables[5] = 0.0 - algebraic_variables[6] = 0.0 - algebraic_variables[7] = 0.0 - algebraic_variables[8] = 0.0 - algebraic_variables[9] = 0.0 - algebraic_variables[10] = 0.0 - - -def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): - pass - - -def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - external_variables[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 2) - find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - external_variables[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 2) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.c deleted file mode 100644 index d95ccf0834..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.c +++ /dev/null @@ -1,571 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.7.0. */ - -#include "model.dae.for.tracking.control.h" - -#include -#include - -const char VERSION[] = "0.8.0"; -const char LIBCELLML_VERSION[] = "0.7.0"; - -const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 5; -const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_VARIABLE_COUNT = 12; - -const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; - -const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane"}, - {"h", "dimensionless", "sodium_channel_h_gate"}, - {"m", "dimensionless", "sodium_channel_m_gate"}, - {"n", "dimensionless", "potassium_channel_n_gate"} -}; - -const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane"}, - {"E_R", "millivolt", "membrane"}, - {"g_L", "milliS_per_cm2", "leakage_current"}, - {"g_Na", "milliS_per_cm2", "sodium_channel"}, - {"g_K", "milliS_per_cm2", "potassium_channel"} -}; - -const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_K", "millivolt", "potassium_channel"} -}; - -const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane"}, - {"i_L", "microA_per_cm2", "leakage_current"}, - {"i_K", "microA_per_cm2", "potassium_channel"}, - {"i_Na", "microA_per_cm2", "sodium_channel"}, - {"E_L", "millivolt", "leakage_current"}, - {"E_Na", "millivolt", "sodium_channel"}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate"} -}; - -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] = algebraicVariables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; -} - -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *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; - - rates[0] = u[0]; - - f[0] = rates[0]-(-(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0])-0.0; -} - -void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = rates[0]; - - nlaSolve(objectiveFunction1, u, 1, &rfi); - - rates[0] = u[0]; -} - -void objectiveFunction2(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[4] = u[0]; - - f[0] = algebraicVariables[4]-(constants[1]-10.613)-0.0; -} - -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[4]; - - nlaSolve(objectiveFunction2, u, 1, &rfi); - - algebraicVariables[4] = 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[1] = u[0]; - - f[0] = algebraicVariables[1]-constants[2]*(states[0]-algebraicVariables[4])-0.0; -} - -void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[1]; - - nlaSolve(objectiveFunction3, u, 1, &rfi); - - algebraicVariables[1] = u[0]; -} - -void objectiveFunction4(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[5] = u[0]; - - f[0] = algebraicVariables[5]-(constants[1]-115.0)-0.0; -} - -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[5]; - - nlaSolve(objectiveFunction4, u, 1, &rfi); - - algebraicVariables[5] = 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[3] = u[0]; - - f[0] = algebraicVariables[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraicVariables[5])-0.0; -} - -void findRoot5(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[3]; - - nlaSolve(objectiveFunction5, u, 1, &rfi); - - algebraicVariables[3] = 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[7] = u[0]; - - f[0] = algebraicVariables[7]-4.0*exp(states[0]/18.0)-0.0; -} - -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[7]; - - nlaSolve(objectiveFunction6, u, 1, &rfi); - - algebraicVariables[7] = 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; - - rates[2] = u[0]; - - f[0] = rates[2]-(algebraicVariables[6]*(1.0-states[2])-algebraicVariables[7]*states[2])-0.0; -} - -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] = rates[2]; - - nlaSolve(objectiveFunction7, u, 1, &rfi); - - rates[2] = 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] = algebraicVariables[8]-0.07*exp(states[0]/20.0)-0.0; -} - -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] = algebraicVariables[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; -} - -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; - - rates[1] = u[0]; - - f[0] = rates[1]-(algebraicVariables[8]*(1.0-states[1])-algebraicVariables[9]*states[1])-0.0; -} - -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] = rates[1]; - - nlaSolve(objectiveFunction10, u, 1, &rfi); - - rates[1] = 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[2] = u[0]; - - f[0] = algebraicVariables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[0])-0.0; -} - -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[2]; - - nlaSolve(objectiveFunction11, u, 1, &rfi); - - algebraicVariables[2] = 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[10] = u[0]; - - f[0] = algebraicVariables[10]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; -} - -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[10]; - - nlaSolve(objectiveFunction12, u, 1, &rfi); - - algebraicVariables[10] = 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[11] = u[0]; - - f[0] = algebraicVariables[11]-0.125*exp(states[0]/80.0)-0.0; -} - -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[11]; - - nlaSolve(objectiveFunction13, u, 1, &rfi); - - algebraicVariables[11] = 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; - - rates[3] = u[0]; - - f[0] = rates[3]-(algebraicVariables[10]*(1.0-states[3])-algebraicVariables[11]*states[3])-0.0; -} - -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] = rates[3]; - - nlaSolve(objectiveFunction14, u, 1, &rfi); - - rates[3] = u[0]; -} - -void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; - rates[0] = 0.0; - rates[1] = 0.0; - rates[2] = 0.0; - rates[3] = 0.0; - constants[0] = 1.0; - constants[1] = 0.0; - constants[2] = 0.3; - constants[3] = 120.0; - constants[4] = 36.0; - algebraicVariables[0] = 0.0; - algebraicVariables[1] = 0.0; - algebraicVariables[2] = 0.0; - algebraicVariables[3] = 0.0; - algebraicVariables[4] = 0.0; - algebraicVariables[5] = 0.0; - algebraicVariables[7] = 0.0; - algebraicVariables[8] = 0.0; - algebraicVariables[9] = 0.0; - algebraicVariables[10] = 0.0; - algebraicVariables[11] = 0.0; -} - -void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - computedConstants[0] = constants[1]+12.0; -} - -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); -} - -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); -} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.py deleted file mode 100644 index ffede99421..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.py +++ /dev/null @@ -1,491 +0,0 @@ -# The content of this file was generated using the Python profile of libCellML 0.7.0. - -from enum import Enum -from math import * - - -__version__ = "0.8.0" -LIBCELLML_VERSION = "0.7.0" - -STATE_COUNT = 4 -CONSTANT_COUNT = 5 -COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_VARIABLE_COUNT = 12 - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} - -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane"}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} -] - -CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, - {"name": "E_R", "units": "millivolt", "component": "membrane"}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} -] - -COMPUTED_CONSTANT_INFO = [ - {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} -] - -ALGEBRAIC_VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} -] - - -def leq_func(x, y): - return 1.0 if x <= y else 0.0 - - -def geq_func(x, y): - return 1.0 if x >= y else 0.0 - - -def and_func(x, y): - return 1.0 if bool(x) & bool(y) else 0.0 - - -def create_states_array(): - return [nan]*STATE_COUNT - - -def create_constants_array(): - return [nan]*CONSTANT_COUNT - - -def create_computed_constants_array(): - return [nan]*COMPUTED_CONSTANT_COUNT - - -def create_algebraic_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] - - algebraic_variables[0] = u[0] - - f[0] = algebraic_variables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - rates[0] = u[0] - - f[0] = rates[0]-(-(-algebraic_variables[0]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1])/constants[0])-0.0 - - -def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[0] - - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[0] = u[0] - - -def objective_function_2(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - - algebraic_variables[4] = u[0] - - f[0] = algebraic_variables[4]-(constants[1]-10.613)-0.0 - - -def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[4] - - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[4] = 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] - - algebraic_variables[1] = u[0] - - f[0] = algebraic_variables[1]-constants[2]*(states[0]-algebraic_variables[4])-0.0 - - -def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[1] - - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[1] = u[0] - - -def objective_function_4(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - - algebraic_variables[5] = u[0] - - f[0] = algebraic_variables[5]-(constants[1]-115.0)-0.0 - - -def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[5] - - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[5] = 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] - - algebraic_variables[3] = u[0] - - f[0] = algebraic_variables[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic_variables[5])-0.0 - - -def find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[3] - - u = nla_solve(objective_function_5, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[3] = 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] - - algebraic_variables[7] = u[0] - - f[0] = algebraic_variables[7]-4.0*exp(states[0]/18.0)-0.0 - - -def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[7] - - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[7] = 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] - - rates[2] = u[0] - - f[0] = rates[2]-(algebraic_variables[6]*(1.0-states[2])-algebraic_variables[7]*states[2])-0.0 - - -def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[2] - - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[2] = 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] - - algebraic_variables[8] = u[0] - - f[0] = algebraic_variables[8]-0.07*exp(states[0]/20.0)-0.0 - - -def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[8] - - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[9] = u[0] - - f[0] = algebraic_variables[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 - - -def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[9] - - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - rates[1] = u[0] - - f[0] = rates[1]-(algebraic_variables[8]*(1.0-states[1])-algebraic_variables[9]*states[1])-0.0 - - -def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[1] - - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[1] = 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] - - algebraic_variables[2] = u[0] - - f[0] = algebraic_variables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[0])-0.0 - - -def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[2] - - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[2] = 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] - - algebraic_variables[10] = u[0] - - f[0] = algebraic_variables[10]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 - - -def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[10] - - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[10] = 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] - - algebraic_variables[11] = u[0] - - f[0] = algebraic_variables[11]-0.125*exp(states[0]/80.0)-0.0 - - -def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[11] - - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[11] = 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] - - rates[3] = u[0] - - f[0] = rates[3]-(algebraic_variables[10]*(1.0-states[3])-algebraic_variables[11]*states[3])-0.0 - - -def find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[3] - - u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[3] = u[0] - - -def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 - rates[0] = 0.0 - rates[1] = 0.0 - rates[2] = 0.0 - rates[3] = 0.0 - constants[0] = 1.0 - constants[1] = 0.0 - constants[2] = 0.3 - constants[3] = 120.0 - constants[4] = 36.0 - algebraic_variables[0] = 0.0 - algebraic_variables[1] = 0.0 - algebraic_variables[2] = 0.0 - algebraic_variables[3] = 0.0 - algebraic_variables[4] = 0.0 - algebraic_variables[5] = 0.0 - algebraic_variables[7] = 0.0 - algebraic_variables[8] = 0.0 - algebraic_variables[9] = 0.0 - algebraic_variables[10] = 0.0 - algebraic_variables[11] = 0.0 - - -def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): - computed_constants[0] = constants[1]+12.0 - - -def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - algebraic_variables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - algebraic_variables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.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 deleted file mode 100644 index 98cb608fa8..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.c +++ /dev/null @@ -1,574 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.7.0. */ - -#include "model.dae.for.tracking.control.with.externals.h" - -#include -#include - -const char VERSION[] = "0.8.0"; -const char LIBCELLML_VERSION[] = "0.7.0"; - -const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 5; -const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_VARIABLE_COUNT = 11; -const size_t EXTERNAL_VARIABLE_COUNT = 1; - -const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; - -const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane"}, - {"h", "dimensionless", "sodium_channel_h_gate"}, - {"m", "dimensionless", "sodium_channel_m_gate"}, - {"n", "dimensionless", "potassium_channel_n_gate"} -}; - -const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane"}, - {"E_R", "millivolt", "membrane"}, - {"g_L", "milliS_per_cm2", "leakage_current"}, - {"g_Na", "milliS_per_cm2", "sodium_channel"}, - {"g_K", "milliS_per_cm2", "potassium_channel"} -}; - -const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_K", "millivolt", "potassium_channel"} -}; - -const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane"}, - {"i_L", "microA_per_cm2", "leakage_current"}, - {"i_K", "microA_per_cm2", "potassium_channel"}, - {"E_L", "millivolt", "leakage_current"}, - {"E_Na", "millivolt", "sodium_channel"}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate"} -}; - -const VariableInfo EXTERNAL_VARIABLE_INFO[] = { - {"i_Na", "microA_per_cm2", "sodium_channel"} -}; - -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; -} - -double * createExternalVariablesArray() -{ - double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - - for (size_t i = 0; i < EXTERNAL_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; - double *externalVariables; -} 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[0] = u[0]; - - f[0] = algebraicVariables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; -} - -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[0] = u[0]; - - f[0] = rates[0]-(-(-algebraicVariables[0]+externalVariables[0]+algebraicVariables[2]+algebraicVariables[1])/constants[0])-0.0; -} - -void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[0]; - - nlaSolve(objectiveFunction1, u, 1, &rfi); - - rates[0] = u[0]; -} - -void objectiveFunction2(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[3] = u[0]; - - f[0] = algebraicVariables[3]-(constants[1]-10.613)-0.0; -} - -void findRoot2(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[3]; - - nlaSolve(objectiveFunction2, u, 1, &rfi); - - algebraicVariables[3] = u[0]; -} - -void objectiveFunction3(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[1] = u[0]; - - f[0] = algebraicVariables[1]-constants[2]*(states[0]-algebraicVariables[3])-0.0; -} - -void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[1]; - - nlaSolve(objectiveFunction3, u, 1, &rfi); - - algebraicVariables[1] = u[0]; -} - -void objectiveFunction4(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[4] = u[0]; - - f[0] = algebraicVariables[4]-(constants[1]-115.0)-0.0; -} - -void findRoot4(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[4]; - - nlaSolve(objectiveFunction4, u, 1, &rfi); - - algebraicVariables[4] = u[0]; -} - -void objectiveFunction6(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[6] = u[0]; - - f[0] = algebraicVariables[6]-4.0*exp(states[0]/18.0)-0.0; -} - -void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[2] = u[0]; - - f[0] = rates[2]-(algebraicVariables[5]*(1.0-states[2])-algebraicVariables[6]*states[2])-0.0; -} - -void findRoot7(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[2]; - - nlaSolve(objectiveFunction7, u, 1, &rfi); - - rates[2] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[7] = u[0]; - - f[0] = algebraicVariables[7]-0.07*exp(states[0]/20.0)-0.0; -} - -void findRoot8(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[7]; - - nlaSolve(objectiveFunction8, u, 1, &rfi); - - algebraicVariables[7] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[8] = u[0]; - - f[0] = algebraicVariables[8]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; -} - -void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[8]; - - nlaSolve(objectiveFunction9, u, 1, &rfi); - - algebraicVariables[8] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[1] = u[0]; - - f[0] = rates[1]-(algebraicVariables[7]*(1.0-states[1])-algebraicVariables[8]*states[1])-0.0; -} - -void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[1]; - - nlaSolve(objectiveFunction10, u, 1, &rfi); - - rates[1] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[2] = u[0]; - - f[0] = algebraicVariables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[0])-0.0; -} - -void findRoot11(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[2]; - - nlaSolve(objectiveFunction11, u, 1, &rfi); - - algebraicVariables[2] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[9] = u[0]; - - f[0] = algebraicVariables[9]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; -} - -void findRoot12(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[9]; - - nlaSolve(objectiveFunction12, u, 1, &rfi); - - algebraicVariables[9] = u[0]; -} - -void objectiveFunction13(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[10] = u[0]; - - f[0] = algebraicVariables[10]-0.125*exp(states[0]/80.0)-0.0; -} - -void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[10]; - - nlaSolve(objectiveFunction13, u, 1, &rfi); - - algebraicVariables[10] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[3] = u[0]; - - f[0] = rates[3]-(algebraicVariables[9]*(1.0-states[3])-algebraicVariables[10]*states[3])-0.0; -} - -void findRoot14(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[3]; - - nlaSolve(objectiveFunction14, u, 1, &rfi); - - rates[3] = u[0]; -} - -void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; - rates[0] = 0.0; - rates[1] = 0.0; - rates[2] = 0.0; - rates[3] = 0.0; - constants[0] = 1.0; - constants[1] = 0.0; - constants[2] = 0.3; - constants[3] = 120.0; - constants[4] = 36.0; - algebraicVariables[0] = 0.0; - algebraicVariables[1] = 0.0; - algebraicVariables[2] = 0.0; - algebraicVariables[3] = 0.0; - algebraicVariables[4] = 0.0; - algebraicVariables[6] = 0.0; - algebraicVariables[7] = 0.0; - algebraicVariables[8] = 0.0; - algebraicVariables[9] = 0.0; - algebraicVariables[10] = 0.0; -} - -void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - computedConstants[0] = constants[1]+12.0; -} - -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) -{ - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); -} - -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) -{ - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); -} 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 deleted file mode 100644 index b416fe3ba6..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.py +++ /dev/null @@ -1,489 +0,0 @@ -# The content of this file was generated using the Python profile of libCellML 0.7.0. - -from enum import Enum -from math import * - - -__version__ = "0.8.0" -LIBCELLML_VERSION = "0.7.0" - -STATE_COUNT = 4 -CONSTANT_COUNT = 5 -COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_VARIABLE_COUNT = 11 -EXTERNAL_VARIABLE_COUNT = 1 - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} - -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane"}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} -] - -CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, - {"name": "E_R", "units": "millivolt", "component": "membrane"}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} -] - -COMPUTED_CONSTANT_INFO = [ - {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} -] - -ALGEBRAIC_VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} -] - -EXTERNAL_VARIABLE_INFO = [ - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} -] - - -def leq_func(x, y): - return 1.0 if x <= y else 0.0 - - -def geq_func(x, y): - return 1.0 if x >= y else 0.0 - - -def and_func(x, y): - return 1.0 if bool(x) & bool(y) else 0.0 - - -def create_states_array(): - return [nan]*STATE_COUNT - - -def create_constants_array(): - return [nan]*CONSTANT_COUNT - - -def create_computed_constants_array(): - return [nan]*COMPUTED_CONSTANT_COUNT - - -def create_algebraic_variables_array(): - return [nan]*ALGEBRAIC_VARIABLE_COUNT - - -def create_external_variables_array(): - return [nan]*EXTERNAL_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] - external_variables = data[6] - - algebraic_variables[0] = u[0] - - f[0] = algebraic_variables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[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] - external_variables = data[6] - - rates[0] = u[0] - - f[0] = rates[0]-(-(-algebraic_variables[0]+external_variables[0]+algebraic_variables[2]+algebraic_variables[1])/constants[0])-0.0 - - -def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[0] - - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[0] = u[0] - - -def objective_function_2(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[3] = u[0] - - f[0] = algebraic_variables[3]-(constants[1]-10.613)-0.0 - - -def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[3] - - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[3] = u[0] - - -def objective_function_3(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[1] = u[0] - - f[0] = algebraic_variables[1]-constants[2]*(states[0]-algebraic_variables[3])-0.0 - - -def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[1] - - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[1] = u[0] - - -def objective_function_4(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[4] = u[0] - - f[0] = algebraic_variables[4]-(constants[1]-115.0)-0.0 - - -def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[4] - - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[4] = u[0] - - -def objective_function_6(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[6] = u[0] - - f[0] = algebraic_variables[6]-4.0*exp(states[0]/18.0)-0.0 - - -def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[6] - - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[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] - external_variables = data[6] - - rates[2] = u[0] - - f[0] = rates[2]-(algebraic_variables[5]*(1.0-states[2])-algebraic_variables[6]*states[2])-0.0 - - -def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[2] - - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[2] = 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] - external_variables = data[6] - - algebraic_variables[7] = u[0] - - f[0] = algebraic_variables[7]-0.07*exp(states[0]/20.0)-0.0 - - -def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[7] - - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[7] = 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] - external_variables = data[6] - - algebraic_variables[8] = u[0] - - f[0] = algebraic_variables[8]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 - - -def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[8] - - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[8] = 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] - external_variables = data[6] - - rates[1] = u[0] - - f[0] = rates[1]-(algebraic_variables[7]*(1.0-states[1])-algebraic_variables[8]*states[1])-0.0 - - -def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[1] - - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[1] = 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] - external_variables = data[6] - - algebraic_variables[2] = u[0] - - f[0] = algebraic_variables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[0])-0.0 - - -def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[2] - - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[2] = 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] - external_variables = data[6] - - algebraic_variables[9] = u[0] - - f[0] = algebraic_variables[9]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 - - -def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[9] - - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[9] = u[0] - - -def objective_function_13(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[10] = u[0] - - f[0] = algebraic_variables[10]-0.125*exp(states[0]/80.0)-0.0 - - -def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[10] - - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[10] = 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] - external_variables = data[6] - - rates[3] = u[0] - - f[0] = rates[3]-(algebraic_variables[9]*(1.0-states[3])-algebraic_variables[10]*states[3])-0.0 - - -def find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[3] - - u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[3] = u[0] - - -def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 - rates[0] = 0.0 - rates[1] = 0.0 - rates[2] = 0.0 - rates[3] = 0.0 - constants[0] = 1.0 - constants[1] = 0.0 - constants[2] = 0.3 - constants[3] = 120.0 - constants[4] = 36.0 - algebraic_variables[0] = 0.0 - algebraic_variables[1] = 0.0 - algebraic_variables[2] = 0.0 - algebraic_variables[3] = 0.0 - algebraic_variables[4] = 0.0 - algebraic_variables[6] = 0.0 - algebraic_variables[7] = 0.0 - algebraic_variables[8] = 0.0 - algebraic_variables[9] = 0.0 - algebraic_variables[10] = 0.0 - - -def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): - computed_constants[0] = constants[1]+12.0 - - -def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) 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 deleted file mode 100644 index 7ea5ebb03d..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.c +++ /dev/null @@ -1,570 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.7.0. */ - -#include "model.dae.for.tracking.untracked.algebraic.variables.h" - -#include -#include - -const char VERSION[] = "0.8.0"; -const char LIBCELLML_VERSION[] = "0.7.0"; - -const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 5; -const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_VARIABLE_COUNT = 11; - -const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; - -const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane"}, - {"h", "dimensionless", "sodium_channel_h_gate"}, - {"m", "dimensionless", "sodium_channel_m_gate"}, - {"n", "dimensionless", "potassium_channel_n_gate"} -}; - -const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane"}, - {"E_R", "millivolt", "membrane"}, - {"g_L", "milliS_per_cm2", "leakage_current"}, - {"g_Na", "milliS_per_cm2", "sodium_channel"}, - {"g_K", "milliS_per_cm2", "potassium_channel"} -}; - -const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_K", "millivolt", "potassium_channel"} -}; - -const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane"}, - {"i_L", "microA_per_cm2", "leakage_current"}, - {"i_K", "microA_per_cm2", "potassium_channel"}, - {"i_Na", "microA_per_cm2", "sodium_channel"}, - {"E_L", "millivolt", "leakage_current"}, - {"E_Na", "millivolt", "sodium_channel"}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate"} -}; - -double * createStatesArray() -{ - 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] = algebraicVariables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; -} - -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *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; - - rates[0] = u[0]; - - f[0] = rates[0]-(-(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0])-0.0; -} - -void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = rates[0]; - - nlaSolve(objectiveFunction1, u, 1, &rfi); - - rates[0] = u[0]; -} - -void objectiveFunction2(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[4] = u[0]; - - f[0] = algebraicVariables[4]-(constants[1]-10.613)-0.0; -} - -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[4]; - - nlaSolve(objectiveFunction2, u, 1, &rfi); - - algebraicVariables[4] = 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[1] = u[0]; - - f[0] = algebraicVariables[1]-constants[2]*(states[0]-algebraicVariables[4])-0.0; -} - -void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[1]; - - nlaSolve(objectiveFunction3, u, 1, &rfi); - - algebraicVariables[1] = u[0]; -} - -void objectiveFunction4(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[5] = u[0]; - - f[0] = algebraicVariables[5]-(constants[1]-115.0)-0.0; -} - -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[5]; - - nlaSolve(objectiveFunction4, u, 1, &rfi); - - algebraicVariables[5] = 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[3] = u[0]; - - f[0] = algebraicVariables[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraicVariables[5])-0.0; -} - -void findRoot5(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[3]; - - nlaSolve(objectiveFunction5, u, 1, &rfi); - - algebraicVariables[3] = 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] = algebraicVariables[6]-4.0*exp(states[0]/18.0)-0.0; -} - -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; - - rates[2] = u[0]; - - double sodium_channel_m_gate_alpha_m = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - - f[0] = rates[2]-(sodium_channel_m_gate_alpha_m*(1.0-states[2])-algebraicVariables[6]*states[2])-0.0; -} - -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] = rates[2]; - - nlaSolve(objectiveFunction7, u, 1, &rfi); - - rates[2] = 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[7] = u[0]; - - f[0] = algebraicVariables[7]-0.07*exp(states[0]/20.0)-0.0; -} - -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[7]; - - nlaSolve(objectiveFunction8, u, 1, &rfi); - - algebraicVariables[7] = 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[8] = u[0]; - - f[0] = algebraicVariables[8]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; -} - -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[8]; - - nlaSolve(objectiveFunction9, u, 1, &rfi); - - algebraicVariables[8] = 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; - - rates[1] = u[0]; - - f[0] = rates[1]-(algebraicVariables[7]*(1.0-states[1])-algebraicVariables[8]*states[1])-0.0; -} - -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] = rates[1]; - - nlaSolve(objectiveFunction10, u, 1, &rfi); - - rates[1] = 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[2] = u[0]; - - f[0] = algebraicVariables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[0])-0.0; -} - -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[2]; - - nlaSolve(objectiveFunction11, u, 1, &rfi); - - algebraicVariables[2] = 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[9] = u[0]; - - f[0] = algebraicVariables[9]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; -} - -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[9]; - - nlaSolve(objectiveFunction12, u, 1, &rfi); - - algebraicVariables[9] = u[0]; -} - -void objectiveFunction13(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[10] = u[0]; - - f[0] = algebraicVariables[10]-0.125*exp(states[0]/80.0)-0.0; -} - -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[10]; - - nlaSolve(objectiveFunction13, u, 1, &rfi); - - algebraicVariables[10] = 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; - - rates[3] = u[0]; - - f[0] = rates[3]-(algebraicVariables[9]*(1.0-states[3])-algebraicVariables[10]*states[3])-0.0; -} - -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] = rates[3]; - - nlaSolve(objectiveFunction14, u, 1, &rfi); - - rates[3] = u[0]; -} - -void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; - rates[0] = 0.0; - rates[1] = 0.0; - rates[2] = 0.0; - rates[3] = 0.0; - constants[0] = 1.0; - constants[1] = 0.0; - constants[2] = 0.3; - constants[3] = 120.0; - constants[4] = 36.0; - algebraicVariables[0] = 0.0; - algebraicVariables[1] = 0.0; - algebraicVariables[2] = 0.0; - algebraicVariables[3] = 0.0; - algebraicVariables[4] = 0.0; - algebraicVariables[5] = 0.0; - algebraicVariables[6] = 0.0; - algebraicVariables[7] = 0.0; - algebraicVariables[8] = 0.0; - algebraicVariables[9] = 0.0; - algebraicVariables[10] = 0.0; -} - -void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - computedConstants[0] = constants[1]+12.0; -} - -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); -} - -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); -} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.py deleted file mode 100644 index af033f17bd..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.py +++ /dev/null @@ -1,490 +0,0 @@ -# The content of this file was generated using the Python profile of libCellML 0.7.0. - -from enum import Enum -from math import * - - -__version__ = "0.8.0" -LIBCELLML_VERSION = "0.7.0" - -STATE_COUNT = 4 -CONSTANT_COUNT = 5 -COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_VARIABLE_COUNT = 11 - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} - -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane"}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} -] - -CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, - {"name": "E_R", "units": "millivolt", "component": "membrane"}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} -] - -COMPUTED_CONSTANT_INFO = [ - {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} -] - -ALGEBRAIC_VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} -] - - -def leq_func(x, y): - return 1.0 if x <= y else 0.0 - - -def geq_func(x, y): - return 1.0 if x >= y else 0.0 - - -def and_func(x, y): - return 1.0 if bool(x) & bool(y) else 0.0 - - -def create_states_array(): - return [nan]*STATE_COUNT - - -def create_constants_array(): - return [nan]*CONSTANT_COUNT - - -def create_computed_constants_array(): - return [nan]*COMPUTED_CONSTANT_COUNT - - -def create_algebraic_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] - - algebraic_variables[0] = u[0] - - f[0] = algebraic_variables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - rates[0] = u[0] - - f[0] = rates[0]-(-(-algebraic_variables[0]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1])/constants[0])-0.0 - - -def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[0] - - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[0] = u[0] - - -def objective_function_2(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - - algebraic_variables[4] = u[0] - - f[0] = algebraic_variables[4]-(constants[1]-10.613)-0.0 - - -def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[4] - - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[4] = 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] - - algebraic_variables[1] = u[0] - - f[0] = algebraic_variables[1]-constants[2]*(states[0]-algebraic_variables[4])-0.0 - - -def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[1] - - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[1] = u[0] - - -def objective_function_4(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - - algebraic_variables[5] = u[0] - - f[0] = algebraic_variables[5]-(constants[1]-115.0)-0.0 - - -def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[5] - - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[5] = 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] - - algebraic_variables[3] = u[0] - - f[0] = algebraic_variables[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic_variables[5])-0.0 - - -def find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[3] - - u = nla_solve(objective_function_5, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[3] = 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] - - algebraic_variables[6] = u[0] - - f[0] = algebraic_variables[6]-4.0*exp(states[0]/18.0)-0.0 - - -def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[6] - - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - rates[2] = u[0] - - sodium_channel_m_gate_alpha_m = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - - f[0] = rates[2]-(sodium_channel_m_gate_alpha_m*(1.0-states[2])-algebraic_variables[6]*states[2])-0.0 - - -def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[2] - - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[2] = 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] - - algebraic_variables[7] = u[0] - - f[0] = algebraic_variables[7]-0.07*exp(states[0]/20.0)-0.0 - - -def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[7] - - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[7] = 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] - - algebraic_variables[8] = u[0] - - f[0] = algebraic_variables[8]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 - - -def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[8] - - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[8] = 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] - - rates[1] = u[0] - - f[0] = rates[1]-(algebraic_variables[7]*(1.0-states[1])-algebraic_variables[8]*states[1])-0.0 - - -def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[1] - - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[1] = 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] - - algebraic_variables[2] = u[0] - - f[0] = algebraic_variables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[0])-0.0 - - -def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[2] - - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[2] = 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] - - algebraic_variables[9] = u[0] - - f[0] = algebraic_variables[9]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 - - -def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[9] - - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[9] = u[0] - - -def objective_function_13(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - - algebraic_variables[10] = u[0] - - f[0] = algebraic_variables[10]-0.125*exp(states[0]/80.0)-0.0 - - -def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[10] - - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[10] = 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] - - rates[3] = u[0] - - f[0] = rates[3]-(algebraic_variables[9]*(1.0-states[3])-algebraic_variables[10]*states[3])-0.0 - - -def find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[3] - - u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[3] = u[0] - - -def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 - rates[0] = 0.0 - rates[1] = 0.0 - rates[2] = 0.0 - rates[3] = 0.0 - constants[0] = 1.0 - constants[1] = 0.0 - constants[2] = 0.3 - constants[3] = 120.0 - constants[4] = 36.0 - algebraic_variables[0] = 0.0 - algebraic_variables[1] = 0.0 - algebraic_variables[2] = 0.0 - algebraic_variables[3] = 0.0 - algebraic_variables[4] = 0.0 - algebraic_variables[5] = 0.0 - algebraic_variables[6] = 0.0 - algebraic_variables[7] = 0.0 - algebraic_variables[8] = 0.0 - algebraic_variables[9] = 0.0 - algebraic_variables[10] = 0.0 - - -def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): - computed_constants[0] = constants[1]+12.0 - - -def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(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_4(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(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_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.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 deleted file mode 100644 index e0622c37a2..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.c +++ /dev/null @@ -1,574 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.7.0. */ - -#include "model.dae.for.tracking.untracked.algebraic.variables.with.externals.h" - -#include -#include - -const char VERSION[] = "0.8.0"; -const char LIBCELLML_VERSION[] = "0.7.0"; - -const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 5; -const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_VARIABLE_COUNT = 11; -const size_t EXTERNAL_VARIABLE_COUNT = 1; - -const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; - -const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane"}, - {"h", "dimensionless", "sodium_channel_h_gate"}, - {"m", "dimensionless", "sodium_channel_m_gate"}, - {"n", "dimensionless", "potassium_channel_n_gate"} -}; - -const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane"}, - {"E_R", "millivolt", "membrane"}, - {"g_L", "milliS_per_cm2", "leakage_current"}, - {"g_Na", "milliS_per_cm2", "sodium_channel"}, - {"g_K", "milliS_per_cm2", "potassium_channel"} -}; - -const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_K", "millivolt", "potassium_channel"} -}; - -const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane"}, - {"i_L", "microA_per_cm2", "leakage_current"}, - {"i_K", "microA_per_cm2", "potassium_channel"}, - {"E_L", "millivolt", "leakage_current"}, - {"E_Na", "millivolt", "sodium_channel"}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate"} -}; - -const VariableInfo EXTERNAL_VARIABLE_INFO[] = { - {"i_Na", "microA_per_cm2", "sodium_channel"} -}; - -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; -} - -double * createExternalVariablesArray() -{ - double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - - for (size_t i = 0; i < EXTERNAL_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; - double *externalVariables; -} 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[0] = u[0]; - - f[0] = algebraicVariables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; -} - -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[0] = u[0]; - - f[0] = rates[0]-(-(-algebraicVariables[0]+externalVariables[0]+algebraicVariables[2]+algebraicVariables[1])/constants[0])-0.0; -} - -void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[0]; - - nlaSolve(objectiveFunction1, u, 1, &rfi); - - rates[0] = u[0]; -} - -void objectiveFunction2(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[3] = u[0]; - - f[0] = algebraicVariables[3]-(constants[1]-10.613)-0.0; -} - -void findRoot2(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[3]; - - nlaSolve(objectiveFunction2, u, 1, &rfi); - - algebraicVariables[3] = u[0]; -} - -void objectiveFunction3(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[1] = u[0]; - - f[0] = algebraicVariables[1]-constants[2]*(states[0]-algebraicVariables[3])-0.0; -} - -void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[1]; - - nlaSolve(objectiveFunction3, u, 1, &rfi); - - algebraicVariables[1] = u[0]; -} - -void objectiveFunction4(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[4] = u[0]; - - f[0] = algebraicVariables[4]-(constants[1]-115.0)-0.0; -} - -void findRoot4(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[4]; - - nlaSolve(objectiveFunction4, u, 1, &rfi); - - algebraicVariables[4] = u[0]; -} - -void objectiveFunction6(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[6] = u[0]; - - f[0] = algebraicVariables[6]-4.0*exp(states[0]/18.0)-0.0; -} - -void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[2] = u[0]; - - f[0] = rates[2]-(algebraicVariables[5]*(1.0-states[2])-algebraicVariables[6]*states[2])-0.0; -} - -void findRoot7(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[2]; - - nlaSolve(objectiveFunction7, u, 1, &rfi); - - rates[2] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[7] = u[0]; - - f[0] = algebraicVariables[7]-0.07*exp(states[0]/20.0)-0.0; -} - -void findRoot8(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[7]; - - nlaSolve(objectiveFunction8, u, 1, &rfi); - - algebraicVariables[7] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[8] = u[0]; - - f[0] = algebraicVariables[8]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; -} - -void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[8]; - - nlaSolve(objectiveFunction9, u, 1, &rfi); - - algebraicVariables[8] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[1] = u[0]; - - f[0] = rates[1]-(algebraicVariables[7]*(1.0-states[1])-algebraicVariables[8]*states[1])-0.0; -} - -void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[1]; - - nlaSolve(objectiveFunction10, u, 1, &rfi); - - rates[1] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[2] = u[0]; - - f[0] = algebraicVariables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[0])-0.0; -} - -void findRoot11(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[2]; - - nlaSolve(objectiveFunction11, u, 1, &rfi); - - algebraicVariables[2] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[9] = u[0]; - - f[0] = algebraicVariables[9]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; -} - -void findRoot12(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[9]; - - nlaSolve(objectiveFunction12, u, 1, &rfi); - - algebraicVariables[9] = u[0]; -} - -void objectiveFunction13(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[10] = u[0]; - - f[0] = algebraicVariables[10]-0.125*exp(states[0]/80.0)-0.0; -} - -void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[10]; - - nlaSolve(objectiveFunction13, u, 1, &rfi); - - algebraicVariables[10] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[3] = u[0]; - - f[0] = rates[3]-(algebraicVariables[9]*(1.0-states[3])-algebraicVariables[10]*states[3])-0.0; -} - -void findRoot14(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[3]; - - nlaSolve(objectiveFunction14, u, 1, &rfi); - - rates[3] = u[0]; -} - -void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; - rates[0] = 0.0; - rates[1] = 0.0; - rates[2] = 0.0; - rates[3] = 0.0; - constants[0] = 1.0; - constants[1] = 0.0; - constants[2] = 0.3; - constants[3] = 120.0; - constants[4] = 36.0; - algebraicVariables[0] = 0.0; - algebraicVariables[1] = 0.0; - algebraicVariables[2] = 0.0; - algebraicVariables[3] = 0.0; - algebraicVariables[4] = 0.0; - algebraicVariables[6] = 0.0; - algebraicVariables[7] = 0.0; - algebraicVariables[8] = 0.0; - algebraicVariables[9] = 0.0; - algebraicVariables[10] = 0.0; -} - -void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - computedConstants[0] = constants[1]+12.0; -} - -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) -{ - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); -} - -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) -{ - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); -} 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 deleted file mode 100644 index b416fe3ba6..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.py +++ /dev/null @@ -1,489 +0,0 @@ -# The content of this file was generated using the Python profile of libCellML 0.7.0. - -from enum import Enum -from math import * - - -__version__ = "0.8.0" -LIBCELLML_VERSION = "0.7.0" - -STATE_COUNT = 4 -CONSTANT_COUNT = 5 -COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_VARIABLE_COUNT = 11 -EXTERNAL_VARIABLE_COUNT = 1 - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} - -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane"}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} -] - -CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, - {"name": "E_R", "units": "millivolt", "component": "membrane"}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} -] - -COMPUTED_CONSTANT_INFO = [ - {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} -] - -ALGEBRAIC_VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} -] - -EXTERNAL_VARIABLE_INFO = [ - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} -] - - -def leq_func(x, y): - return 1.0 if x <= y else 0.0 - - -def geq_func(x, y): - return 1.0 if x >= y else 0.0 - - -def and_func(x, y): - return 1.0 if bool(x) & bool(y) else 0.0 - - -def create_states_array(): - return [nan]*STATE_COUNT - - -def create_constants_array(): - return [nan]*CONSTANT_COUNT - - -def create_computed_constants_array(): - return [nan]*COMPUTED_CONSTANT_COUNT - - -def create_algebraic_variables_array(): - return [nan]*ALGEBRAIC_VARIABLE_COUNT - - -def create_external_variables_array(): - return [nan]*EXTERNAL_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] - external_variables = data[6] - - algebraic_variables[0] = u[0] - - f[0] = algebraic_variables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[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] - external_variables = data[6] - - rates[0] = u[0] - - f[0] = rates[0]-(-(-algebraic_variables[0]+external_variables[0]+algebraic_variables[2]+algebraic_variables[1])/constants[0])-0.0 - - -def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[0] - - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[0] = u[0] - - -def objective_function_2(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[3] = u[0] - - f[0] = algebraic_variables[3]-(constants[1]-10.613)-0.0 - - -def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[3] - - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[3] = u[0] - - -def objective_function_3(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[1] = u[0] - - f[0] = algebraic_variables[1]-constants[2]*(states[0]-algebraic_variables[3])-0.0 - - -def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[1] - - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[1] = u[0] - - -def objective_function_4(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[4] = u[0] - - f[0] = algebraic_variables[4]-(constants[1]-115.0)-0.0 - - -def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[4] - - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[4] = u[0] - - -def objective_function_6(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[6] = u[0] - - f[0] = algebraic_variables[6]-4.0*exp(states[0]/18.0)-0.0 - - -def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[6] - - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[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] - external_variables = data[6] - - rates[2] = u[0] - - f[0] = rates[2]-(algebraic_variables[5]*(1.0-states[2])-algebraic_variables[6]*states[2])-0.0 - - -def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[2] - - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[2] = 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] - external_variables = data[6] - - algebraic_variables[7] = u[0] - - f[0] = algebraic_variables[7]-0.07*exp(states[0]/20.0)-0.0 - - -def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[7] - - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[7] = 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] - external_variables = data[6] - - algebraic_variables[8] = u[0] - - f[0] = algebraic_variables[8]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 - - -def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[8] - - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[8] = 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] - external_variables = data[6] - - rates[1] = u[0] - - f[0] = rates[1]-(algebraic_variables[7]*(1.0-states[1])-algebraic_variables[8]*states[1])-0.0 - - -def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[1] - - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[1] = 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] - external_variables = data[6] - - algebraic_variables[2] = u[0] - - f[0] = algebraic_variables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[0])-0.0 - - -def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[2] - - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[2] = 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] - external_variables = data[6] - - algebraic_variables[9] = u[0] - - f[0] = algebraic_variables[9]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 - - -def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[9] - - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[9] = u[0] - - -def objective_function_13(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[10] = u[0] - - f[0] = algebraic_variables[10]-0.125*exp(states[0]/80.0)-0.0 - - -def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[10] - - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[10] = 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] - external_variables = data[6] - - rates[3] = u[0] - - f[0] = rates[3]-(algebraic_variables[9]*(1.0-states[3])-algebraic_variables[10]*states[3])-0.0 - - -def find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[3] - - u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[3] = u[0] - - -def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 - rates[0] = 0.0 - rates[1] = 0.0 - rates[2] = 0.0 - rates[3] = 0.0 - constants[0] = 1.0 - constants[1] = 0.0 - constants[2] = 0.3 - constants[3] = 120.0 - constants[4] = 36.0 - algebraic_variables[0] = 0.0 - algebraic_variables[1] = 0.0 - algebraic_variables[2] = 0.0 - algebraic_variables[3] = 0.0 - algebraic_variables[4] = 0.0 - algebraic_variables[6] = 0.0 - algebraic_variables[7] = 0.0 - algebraic_variables[8] = 0.0 - algebraic_variables[9] = 0.0 - algebraic_variables[10] = 0.0 - - -def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): - computed_constants[0] = constants[1]+12.0 - - -def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) 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 deleted file mode 100644 index 6c59f0e3dc..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.c +++ /dev/null @@ -1,571 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.7.0. */ - -#include "model.dae.for.tracking.untracked.computed.constants.h" - -#include -#include - -const char VERSION[] = "0.8.0"; -const char LIBCELLML_VERSION[] = "0.7.0"; - -const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 5; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_VARIABLE_COUNT = 12; - -const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; - -const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane"}, - {"h", "dimensionless", "sodium_channel_h_gate"}, - {"m", "dimensionless", "sodium_channel_m_gate"}, - {"n", "dimensionless", "potassium_channel_n_gate"} -}; - -const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane"}, - {"E_R", "millivolt", "membrane"}, - {"g_L", "milliS_per_cm2", "leakage_current"}, - {"g_Na", "milliS_per_cm2", "sodium_channel"}, - {"g_K", "milliS_per_cm2", "potassium_channel"} -}; - -const VariableInfo COMPUTED_CONSTANT_INFO[] = { -}; - -const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane"}, - {"i_L", "microA_per_cm2", "leakage_current"}, - {"i_K", "microA_per_cm2", "potassium_channel"}, - {"i_Na", "microA_per_cm2", "sodium_channel"}, - {"E_L", "millivolt", "leakage_current"}, - {"E_Na", "millivolt", "sodium_channel"}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate"} -}; - -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] = algebraicVariables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; -} - -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *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; - - rates[0] = u[0]; - - f[0] = rates[0]-(-(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0])-0.0; -} - -void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = rates[0]; - - nlaSolve(objectiveFunction1, u, 1, &rfi); - - rates[0] = u[0]; -} - -void objectiveFunction2(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[4] = u[0]; - - f[0] = algebraicVariables[4]-(constants[1]-10.613)-0.0; -} - -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[4]; - - nlaSolve(objectiveFunction2, u, 1, &rfi); - - algebraicVariables[4] = 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[1] = u[0]; - - f[0] = algebraicVariables[1]-constants[2]*(states[0]-algebraicVariables[4])-0.0; -} - -void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[1]; - - nlaSolve(objectiveFunction3, u, 1, &rfi); - - algebraicVariables[1] = u[0]; -} - -void objectiveFunction4(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[5] = u[0]; - - f[0] = algebraicVariables[5]-(constants[1]-115.0)-0.0; -} - -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[5]; - - nlaSolve(objectiveFunction4, u, 1, &rfi); - - algebraicVariables[5] = 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[3] = u[0]; - - f[0] = algebraicVariables[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraicVariables[5])-0.0; -} - -void findRoot5(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[3]; - - nlaSolve(objectiveFunction5, u, 1, &rfi); - - algebraicVariables[3] = 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[7] = u[0]; - - f[0] = algebraicVariables[7]-4.0*exp(states[0]/18.0)-0.0; -} - -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[7]; - - nlaSolve(objectiveFunction6, u, 1, &rfi); - - algebraicVariables[7] = 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; - - rates[2] = u[0]; - - f[0] = rates[2]-(algebraicVariables[6]*(1.0-states[2])-algebraicVariables[7]*states[2])-0.0; -} - -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] = rates[2]; - - nlaSolve(objectiveFunction7, u, 1, &rfi); - - rates[2] = 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] = algebraicVariables[8]-0.07*exp(states[0]/20.0)-0.0; -} - -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] = algebraicVariables[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; -} - -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; - - rates[1] = u[0]; - - f[0] = rates[1]-(algebraicVariables[8]*(1.0-states[1])-algebraicVariables[9]*states[1])-0.0; -} - -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] = rates[1]; - - nlaSolve(objectiveFunction10, u, 1, &rfi); - - rates[1] = 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[2] = u[0]; - - double potassium_channel_E_K = constants[1]+12.0; - - f[0] = algebraicVariables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-potassium_channel_E_K)-0.0; -} - -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[2]; - - nlaSolve(objectiveFunction11, u, 1, &rfi); - - algebraicVariables[2] = 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[10] = u[0]; - - f[0] = algebraicVariables[10]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; -} - -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[10]; - - nlaSolve(objectiveFunction12, u, 1, &rfi); - - algebraicVariables[10] = 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[11] = u[0]; - - f[0] = algebraicVariables[11]-0.125*exp(states[0]/80.0)-0.0; -} - -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[11]; - - nlaSolve(objectiveFunction13, u, 1, &rfi); - - algebraicVariables[11] = 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; - - rates[3] = u[0]; - - f[0] = rates[3]-(algebraicVariables[10]*(1.0-states[3])-algebraicVariables[11]*states[3])-0.0; -} - -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] = rates[3]; - - nlaSolve(objectiveFunction14, u, 1, &rfi); - - rates[3] = u[0]; -} - -void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; - rates[0] = 0.0; - rates[1] = 0.0; - rates[2] = 0.0; - rates[3] = 0.0; - constants[0] = 1.0; - constants[1] = 0.0; - constants[2] = 0.3; - constants[3] = 120.0; - constants[4] = 36.0; - algebraicVariables[0] = 0.0; - algebraicVariables[1] = 0.0; - algebraicVariables[2] = 0.0; - algebraicVariables[3] = 0.0; - algebraicVariables[4] = 0.0; - algebraicVariables[5] = 0.0; - algebraicVariables[7] = 0.0; - algebraicVariables[8] = 0.0; - algebraicVariables[9] = 0.0; - algebraicVariables[10] = 0.0; - algebraicVariables[11] = 0.0; -} - -void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ -} - -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); -} - -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); -} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.py deleted file mode 100644 index c86689a522..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.py +++ /dev/null @@ -1,492 +0,0 @@ -# The content of this file was generated using the Python profile of libCellML 0.7.0. - -from enum import Enum -from math import * - - -__version__ = "0.8.0" -LIBCELLML_VERSION = "0.7.0" - -STATE_COUNT = 4 -CONSTANT_COUNT = 5 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_VARIABLE_COUNT = 12 - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} - -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane"}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} -] - -CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, - {"name": "E_R", "units": "millivolt", "component": "membrane"}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} -] - -COMPUTED_CONSTANT_INFO = [ -] - -ALGEBRAIC_VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} -] - - -def leq_func(x, y): - return 1.0 if x <= y else 0.0 - - -def geq_func(x, y): - return 1.0 if x >= y else 0.0 - - -def and_func(x, y): - return 1.0 if bool(x) & bool(y) else 0.0 - - -def create_states_array(): - return [nan]*STATE_COUNT - - -def create_constants_array(): - return [nan]*CONSTANT_COUNT - - -def create_computed_constants_array(): - return [nan]*COMPUTED_CONSTANT_COUNT - - -def create_algebraic_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] - - algebraic_variables[0] = u[0] - - f[0] = algebraic_variables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - rates[0] = u[0] - - f[0] = rates[0]-(-(-algebraic_variables[0]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1])/constants[0])-0.0 - - -def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[0] - - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[0] = u[0] - - -def objective_function_2(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - - algebraic_variables[4] = u[0] - - f[0] = algebraic_variables[4]-(constants[1]-10.613)-0.0 - - -def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[4] - - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[4] = 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] - - algebraic_variables[1] = u[0] - - f[0] = algebraic_variables[1]-constants[2]*(states[0]-algebraic_variables[4])-0.0 - - -def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[1] - - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[1] = u[0] - - -def objective_function_4(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - - algebraic_variables[5] = u[0] - - f[0] = algebraic_variables[5]-(constants[1]-115.0)-0.0 - - -def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[5] - - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[5] = 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] - - algebraic_variables[3] = u[0] - - f[0] = algebraic_variables[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic_variables[5])-0.0 - - -def find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[3] - - u = nla_solve(objective_function_5, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[3] = 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] - - algebraic_variables[7] = u[0] - - f[0] = algebraic_variables[7]-4.0*exp(states[0]/18.0)-0.0 - - -def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[7] - - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[7] = 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] - - rates[2] = u[0] - - f[0] = rates[2]-(algebraic_variables[6]*(1.0-states[2])-algebraic_variables[7]*states[2])-0.0 - - -def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[2] - - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[2] = 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] - - algebraic_variables[8] = u[0] - - f[0] = algebraic_variables[8]-0.07*exp(states[0]/20.0)-0.0 - - -def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[8] - - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[9] = u[0] - - f[0] = algebraic_variables[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 - - -def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[9] - - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - rates[1] = u[0] - - f[0] = rates[1]-(algebraic_variables[8]*(1.0-states[1])-algebraic_variables[9]*states[1])-0.0 - - -def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[1] - - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[1] = 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] - - algebraic_variables[2] = u[0] - - potassium_channel_E_K = constants[1]+12.0 - - f[0] = algebraic_variables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-potassium_channel_E_K)-0.0 - - -def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[2] - - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[2] = 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] - - algebraic_variables[10] = u[0] - - f[0] = algebraic_variables[10]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 - - -def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[10] - - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[10] = 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] - - algebraic_variables[11] = u[0] - - f[0] = algebraic_variables[11]-0.125*exp(states[0]/80.0)-0.0 - - -def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[11] - - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[11] = 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] - - rates[3] = u[0] - - f[0] = rates[3]-(algebraic_variables[10]*(1.0-states[3])-algebraic_variables[11]*states[3])-0.0 - - -def find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[3] - - u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[3] = u[0] - - -def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 - rates[0] = 0.0 - rates[1] = 0.0 - rates[2] = 0.0 - rates[3] = 0.0 - constants[0] = 1.0 - constants[1] = 0.0 - constants[2] = 0.3 - constants[3] = 120.0 - constants[4] = 36.0 - algebraic_variables[0] = 0.0 - algebraic_variables[1] = 0.0 - algebraic_variables[2] = 0.0 - algebraic_variables[3] = 0.0 - algebraic_variables[4] = 0.0 - algebraic_variables[5] = 0.0 - algebraic_variables[7] = 0.0 - algebraic_variables[8] = 0.0 - algebraic_variables[9] = 0.0 - algebraic_variables[10] = 0.0 - algebraic_variables[11] = 0.0 - - -def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): - pass - - -def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - algebraic_variables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - algebraic_variables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.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 deleted file mode 100644 index 67a58302ce..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.c +++ /dev/null @@ -1,574 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.7.0. */ - -#include "model.dae.for.tracking.untracked.computed.constants.with.externals.h" - -#include -#include - -const char VERSION[] = "0.8.0"; -const char LIBCELLML_VERSION[] = "0.7.0"; - -const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 5; -const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_VARIABLE_COUNT = 11; -const size_t EXTERNAL_VARIABLE_COUNT = 1; - -const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; - -const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane"}, - {"h", "dimensionless", "sodium_channel_h_gate"}, - {"m", "dimensionless", "sodium_channel_m_gate"}, - {"n", "dimensionless", "potassium_channel_n_gate"} -}; - -const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane"}, - {"E_R", "millivolt", "membrane"}, - {"g_L", "milliS_per_cm2", "leakage_current"}, - {"g_Na", "milliS_per_cm2", "sodium_channel"}, - {"g_K", "milliS_per_cm2", "potassium_channel"} -}; - -const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_K", "millivolt", "potassium_channel"} -}; - -const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane"}, - {"i_L", "microA_per_cm2", "leakage_current"}, - {"i_K", "microA_per_cm2", "potassium_channel"}, - {"E_L", "millivolt", "leakage_current"}, - {"E_Na", "millivolt", "sodium_channel"}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate"} -}; - -const VariableInfo EXTERNAL_VARIABLE_INFO[] = { - {"i_Na", "microA_per_cm2", "sodium_channel"} -}; - -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; -} - -double * createExternalVariablesArray() -{ - double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - - for (size_t i = 0; i < EXTERNAL_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; - double *externalVariables; -} 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[0] = u[0]; - - f[0] = algebraicVariables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; -} - -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[0] = u[0]; - - f[0] = rates[0]-(-(-algebraicVariables[0]+externalVariables[0]+algebraicVariables[2]+algebraicVariables[1])/constants[0])-0.0; -} - -void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[0]; - - nlaSolve(objectiveFunction1, u, 1, &rfi); - - rates[0] = u[0]; -} - -void objectiveFunction2(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[3] = u[0]; - - f[0] = algebraicVariables[3]-(constants[1]-10.613)-0.0; -} - -void findRoot2(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[3]; - - nlaSolve(objectiveFunction2, u, 1, &rfi); - - algebraicVariables[3] = u[0]; -} - -void objectiveFunction3(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[1] = u[0]; - - f[0] = algebraicVariables[1]-constants[2]*(states[0]-algebraicVariables[3])-0.0; -} - -void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[1]; - - nlaSolve(objectiveFunction3, u, 1, &rfi); - - algebraicVariables[1] = u[0]; -} - -void objectiveFunction4(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[4] = u[0]; - - f[0] = algebraicVariables[4]-(constants[1]-115.0)-0.0; -} - -void findRoot4(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[4]; - - nlaSolve(objectiveFunction4, u, 1, &rfi); - - algebraicVariables[4] = u[0]; -} - -void objectiveFunction6(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[6] = u[0]; - - f[0] = algebraicVariables[6]-4.0*exp(states[0]/18.0)-0.0; -} - -void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[2] = u[0]; - - f[0] = rates[2]-(algebraicVariables[5]*(1.0-states[2])-algebraicVariables[6]*states[2])-0.0; -} - -void findRoot7(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[2]; - - nlaSolve(objectiveFunction7, u, 1, &rfi); - - rates[2] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[7] = u[0]; - - f[0] = algebraicVariables[7]-0.07*exp(states[0]/20.0)-0.0; -} - -void findRoot8(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[7]; - - nlaSolve(objectiveFunction8, u, 1, &rfi); - - algebraicVariables[7] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[8] = u[0]; - - f[0] = algebraicVariables[8]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; -} - -void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[8]; - - nlaSolve(objectiveFunction9, u, 1, &rfi); - - algebraicVariables[8] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[1] = u[0]; - - f[0] = rates[1]-(algebraicVariables[7]*(1.0-states[1])-algebraicVariables[8]*states[1])-0.0; -} - -void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[1]; - - nlaSolve(objectiveFunction10, u, 1, &rfi); - - rates[1] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[2] = u[0]; - - f[0] = algebraicVariables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[0])-0.0; -} - -void findRoot11(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[2]; - - nlaSolve(objectiveFunction11, u, 1, &rfi); - - algebraicVariables[2] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[9] = u[0]; - - f[0] = algebraicVariables[9]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; -} - -void findRoot12(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[9]; - - nlaSolve(objectiveFunction12, u, 1, &rfi); - - algebraicVariables[9] = u[0]; -} - -void objectiveFunction13(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[10] = u[0]; - - f[0] = algebraicVariables[10]-0.125*exp(states[0]/80.0)-0.0; -} - -void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[10]; - - nlaSolve(objectiveFunction13, u, 1, &rfi); - - algebraicVariables[10] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[3] = u[0]; - - f[0] = rates[3]-(algebraicVariables[9]*(1.0-states[3])-algebraicVariables[10]*states[3])-0.0; -} - -void findRoot14(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[3]; - - nlaSolve(objectiveFunction14, u, 1, &rfi); - - rates[3] = u[0]; -} - -void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; - rates[0] = 0.0; - rates[1] = 0.0; - rates[2] = 0.0; - rates[3] = 0.0; - constants[0] = 1.0; - constants[1] = 0.0; - constants[2] = 0.3; - constants[3] = 120.0; - constants[4] = 36.0; - algebraicVariables[0] = 0.0; - algebraicVariables[1] = 0.0; - algebraicVariables[2] = 0.0; - algebraicVariables[3] = 0.0; - algebraicVariables[4] = 0.0; - algebraicVariables[6] = 0.0; - algebraicVariables[7] = 0.0; - algebraicVariables[8] = 0.0; - algebraicVariables[9] = 0.0; - algebraicVariables[10] = 0.0; -} - -void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - computedConstants[0] = constants[1]+12.0; -} - -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) -{ - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); -} - -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) -{ - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); -} 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 deleted file mode 100644 index b416fe3ba6..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.py +++ /dev/null @@ -1,489 +0,0 @@ -# The content of this file was generated using the Python profile of libCellML 0.7.0. - -from enum import Enum -from math import * - - -__version__ = "0.8.0" -LIBCELLML_VERSION = "0.7.0" - -STATE_COUNT = 4 -CONSTANT_COUNT = 5 -COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_VARIABLE_COUNT = 11 -EXTERNAL_VARIABLE_COUNT = 1 - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} - -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane"}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} -] - -CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, - {"name": "E_R", "units": "millivolt", "component": "membrane"}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} -] - -COMPUTED_CONSTANT_INFO = [ - {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} -] - -ALGEBRAIC_VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} -] - -EXTERNAL_VARIABLE_INFO = [ - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} -] - - -def leq_func(x, y): - return 1.0 if x <= y else 0.0 - - -def geq_func(x, y): - return 1.0 if x >= y else 0.0 - - -def and_func(x, y): - return 1.0 if bool(x) & bool(y) else 0.0 - - -def create_states_array(): - return [nan]*STATE_COUNT - - -def create_constants_array(): - return [nan]*CONSTANT_COUNT - - -def create_computed_constants_array(): - return [nan]*COMPUTED_CONSTANT_COUNT - - -def create_algebraic_variables_array(): - return [nan]*ALGEBRAIC_VARIABLE_COUNT - - -def create_external_variables_array(): - return [nan]*EXTERNAL_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] - external_variables = data[6] - - algebraic_variables[0] = u[0] - - f[0] = algebraic_variables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[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] - external_variables = data[6] - - rates[0] = u[0] - - f[0] = rates[0]-(-(-algebraic_variables[0]+external_variables[0]+algebraic_variables[2]+algebraic_variables[1])/constants[0])-0.0 - - -def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[0] - - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[0] = u[0] - - -def objective_function_2(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[3] = u[0] - - f[0] = algebraic_variables[3]-(constants[1]-10.613)-0.0 - - -def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[3] - - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[3] = u[0] - - -def objective_function_3(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[1] = u[0] - - f[0] = algebraic_variables[1]-constants[2]*(states[0]-algebraic_variables[3])-0.0 - - -def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[1] - - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[1] = u[0] - - -def objective_function_4(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[4] = u[0] - - f[0] = algebraic_variables[4]-(constants[1]-115.0)-0.0 - - -def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[4] - - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[4] = u[0] - - -def objective_function_6(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[6] = u[0] - - f[0] = algebraic_variables[6]-4.0*exp(states[0]/18.0)-0.0 - - -def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[6] - - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[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] - external_variables = data[6] - - rates[2] = u[0] - - f[0] = rates[2]-(algebraic_variables[5]*(1.0-states[2])-algebraic_variables[6]*states[2])-0.0 - - -def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[2] - - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[2] = 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] - external_variables = data[6] - - algebraic_variables[7] = u[0] - - f[0] = algebraic_variables[7]-0.07*exp(states[0]/20.0)-0.0 - - -def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[7] - - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[7] = 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] - external_variables = data[6] - - algebraic_variables[8] = u[0] - - f[0] = algebraic_variables[8]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 - - -def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[8] - - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[8] = 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] - external_variables = data[6] - - rates[1] = u[0] - - f[0] = rates[1]-(algebraic_variables[7]*(1.0-states[1])-algebraic_variables[8]*states[1])-0.0 - - -def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[1] - - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[1] = 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] - external_variables = data[6] - - algebraic_variables[2] = u[0] - - f[0] = algebraic_variables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[0])-0.0 - - -def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[2] - - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[2] = 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] - external_variables = data[6] - - algebraic_variables[9] = u[0] - - f[0] = algebraic_variables[9]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 - - -def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[9] - - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[9] = u[0] - - -def objective_function_13(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[10] = u[0] - - f[0] = algebraic_variables[10]-0.125*exp(states[0]/80.0)-0.0 - - -def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[10] - - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[10] = 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] - external_variables = data[6] - - rates[3] = u[0] - - f[0] = rates[3]-(algebraic_variables[9]*(1.0-states[3])-algebraic_variables[10]*states[3])-0.0 - - -def find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[3] - - u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[3] = u[0] - - -def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 - rates[0] = 0.0 - rates[1] = 0.0 - rates[2] = 0.0 - rates[3] = 0.0 - constants[0] = 1.0 - constants[1] = 0.0 - constants[2] = 0.3 - constants[3] = 120.0 - constants[4] = 36.0 - algebraic_variables[0] = 0.0 - algebraic_variables[1] = 0.0 - algebraic_variables[2] = 0.0 - algebraic_variables[3] = 0.0 - algebraic_variables[4] = 0.0 - algebraic_variables[6] = 0.0 - algebraic_variables[7] = 0.0 - algebraic_variables[8] = 0.0 - algebraic_variables[9] = 0.0 - algebraic_variables[10] = 0.0 - - -def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): - computed_constants[0] = constants[1]+12.0 - - -def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) 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 deleted file mode 100644 index fc613372ab..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.c +++ /dev/null @@ -1,574 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.7.0. */ - -#include "model.dae.for.tracking.untracked.constants.h" - -#include -#include - -const char VERSION[] = "0.8.0"; -const char LIBCELLML_VERSION[] = "0.7.0"; - -const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_VARIABLE_COUNT = 12; - -const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; - -const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane"}, - {"h", "dimensionless", "sodium_channel_h_gate"}, - {"m", "dimensionless", "sodium_channel_m_gate"}, - {"n", "dimensionless", "potassium_channel_n_gate"} -}; - -const VariableInfo CONSTANT_INFO[] = { -}; - -const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_K", "millivolt", "potassium_channel"} -}; - -const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane"}, - {"i_L", "microA_per_cm2", "leakage_current"}, - {"i_K", "microA_per_cm2", "potassium_channel"}, - {"i_Na", "microA_per_cm2", "sodium_channel"}, - {"E_L", "millivolt", "leakage_current"}, - {"E_Na", "millivolt", "sodium_channel"}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate"} -}; - -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] = algebraicVariables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; -} - -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *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; - - rates[0] = u[0]; - - double membrane_Cm = 1.0; - - f[0] = rates[0]-(-(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/membrane_Cm)-0.0; -} - -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] = rates[0]; - - nlaSolve(objectiveFunction1, u, 1, &rfi); - - rates[0] = u[0]; -} - -void objectiveFunction2(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[4] = u[0]; - - double membrane_E_R = 0.0; - - f[0] = algebraicVariables[4]-(membrane_E_R-10.613)-0.0; -} - -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[4]; - - nlaSolve(objectiveFunction2, u, 1, &rfi); - - algebraicVariables[4] = 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[1] = u[0]; - - double leakage_current_g_L = 0.3; - - f[0] = algebraicVariables[1]-leakage_current_g_L*(states[0]-algebraicVariables[4])-0.0; -} - -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[1]; - - nlaSolve(objectiveFunction3, u, 1, &rfi); - - algebraicVariables[1] = u[0]; -} - -void objectiveFunction4(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[5] = u[0]; - - double membrane_E_R = 0.0; - - f[0] = algebraicVariables[5]-(membrane_E_R-115.0)-0.0; -} - -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[5]; - - nlaSolve(objectiveFunction4, u, 1, &rfi); - - algebraicVariables[5] = 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[3] = u[0]; - - double sodium_channel_g_Na = 120.0; - - f[0] = algebraicVariables[3]-sodium_channel_g_Na*pow(states[2], 3.0)*states[1]*(states[0]-algebraicVariables[5])-0.0; -} - -void findRoot5(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[3]; - - nlaSolve(objectiveFunction5, u, 1, &rfi); - - algebraicVariables[3] = 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[7] = u[0]; - - f[0] = algebraicVariables[7]-4.0*exp(states[0]/18.0)-0.0; -} - -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[7]; - - nlaSolve(objectiveFunction6, u, 1, &rfi); - - algebraicVariables[7] = 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; - - rates[2] = u[0]; - - f[0] = rates[2]-(algebraicVariables[6]*(1.0-states[2])-algebraicVariables[7]*states[2])-0.0; -} - -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] = rates[2]; - - nlaSolve(objectiveFunction7, u, 1, &rfi); - - rates[2] = 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] = algebraicVariables[8]-0.07*exp(states[0]/20.0)-0.0; -} - -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] = algebraicVariables[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; -} - -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; - - rates[1] = u[0]; - - f[0] = rates[1]-(algebraicVariables[8]*(1.0-states[1])-algebraicVariables[9]*states[1])-0.0; -} - -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] = rates[1]; - - nlaSolve(objectiveFunction10, u, 1, &rfi); - - rates[1] = 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[2] = u[0]; - - double potassium_channel_g_K = 36.0; - - f[0] = algebraicVariables[2]-potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computedConstants[0])-0.0; -} - -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[2]; - - nlaSolve(objectiveFunction11, u, 1, &rfi); - - algebraicVariables[2] = 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[10] = u[0]; - - f[0] = algebraicVariables[10]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; -} - -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[10]; - - nlaSolve(objectiveFunction12, u, 1, &rfi); - - algebraicVariables[10] = 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[11] = u[0]; - - f[0] = algebraicVariables[11]-0.125*exp(states[0]/80.0)-0.0; -} - -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[11]; - - nlaSolve(objectiveFunction13, u, 1, &rfi); - - algebraicVariables[11] = 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; - - rates[3] = u[0]; - - f[0] = rates[3]-(algebraicVariables[10]*(1.0-states[3])-algebraicVariables[11]*states[3])-0.0; -} - -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] = rates[3]; - - nlaSolve(objectiveFunction14, u, 1, &rfi); - - rates[3] = u[0]; -} - -void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; - rates[0] = 0.0; - rates[1] = 0.0; - rates[2] = 0.0; - rates[3] = 0.0; - algebraicVariables[0] = 0.0; - algebraicVariables[1] = 0.0; - algebraicVariables[2] = 0.0; - algebraicVariables[3] = 0.0; - algebraicVariables[4] = 0.0; - algebraicVariables[5] = 0.0; - algebraicVariables[7] = 0.0; - algebraicVariables[8] = 0.0; - algebraicVariables[9] = 0.0; - algebraicVariables[10] = 0.0; - algebraicVariables[11] = 0.0; -} - -void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - double membrane_E_R = 0.0; - computedConstants[0] = membrane_E_R+12.0; -} - -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); -} - -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); -} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.py deleted file mode 100644 index f52afeb9af..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.py +++ /dev/null @@ -1,494 +0,0 @@ -# The content of this file was generated using the Python profile of libCellML 0.7.0. - -from enum import Enum -from math import * - - -__version__ = "0.8.0" -LIBCELLML_VERSION = "0.7.0" - -STATE_COUNT = 4 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_VARIABLE_COUNT = 12 - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} - -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane"}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} -] - -CONSTANT_INFO = [ -] - -COMPUTED_CONSTANT_INFO = [ - {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} -] - -ALGEBRAIC_VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} -] - - -def leq_func(x, y): - return 1.0 if x <= y else 0.0 - - -def geq_func(x, y): - return 1.0 if x >= y else 0.0 - - -def and_func(x, y): - return 1.0 if bool(x) & bool(y) else 0.0 - - -def create_states_array(): - return [nan]*STATE_COUNT - - -def create_constants_array(): - return [nan]*CONSTANT_COUNT - - -def create_computed_constants_array(): - return [nan]*COMPUTED_CONSTANT_COUNT - - -def create_algebraic_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] - - algebraic_variables[0] = u[0] - - f[0] = algebraic_variables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - rates[0] = u[0] - - membrane_Cm = 1.0 - - f[0] = rates[0]-(-(-algebraic_variables[0]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1])/membrane_Cm)-0.0 - - -def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[0] - - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[0] = u[0] - - -def objective_function_2(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - - algebraic_variables[4] = u[0] - - membrane_E_R = 0.0 - - f[0] = algebraic_variables[4]-(membrane_E_R-10.613)-0.0 - - -def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[4] - - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[4] = 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] - - algebraic_variables[1] = u[0] - - leakage_current_g_L = 0.3 - - f[0] = algebraic_variables[1]-leakage_current_g_L*(states[0]-algebraic_variables[4])-0.0 - - -def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[1] - - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[1] = u[0] - - -def objective_function_4(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - - algebraic_variables[5] = u[0] - - membrane_E_R = 0.0 - - f[0] = algebraic_variables[5]-(membrane_E_R-115.0)-0.0 - - -def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[5] - - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[5] = 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] - - algebraic_variables[3] = u[0] - - sodium_channel_g_Na = 120.0 - - f[0] = algebraic_variables[3]-sodium_channel_g_Na*pow(states[2], 3.0)*states[1]*(states[0]-algebraic_variables[5])-0.0 - - -def find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[3] - - u = nla_solve(objective_function_5, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[3] = 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] - - algebraic_variables[7] = u[0] - - f[0] = algebraic_variables[7]-4.0*exp(states[0]/18.0)-0.0 - - -def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[7] - - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[7] = 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] - - rates[2] = u[0] - - f[0] = rates[2]-(algebraic_variables[6]*(1.0-states[2])-algebraic_variables[7]*states[2])-0.0 - - -def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[2] - - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[2] = 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] - - algebraic_variables[8] = u[0] - - f[0] = algebraic_variables[8]-0.07*exp(states[0]/20.0)-0.0 - - -def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[8] - - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[9] = u[0] - - f[0] = algebraic_variables[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 - - -def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[9] - - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - rates[1] = u[0] - - f[0] = rates[1]-(algebraic_variables[8]*(1.0-states[1])-algebraic_variables[9]*states[1])-0.0 - - -def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[1] - - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[1] = 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] - - algebraic_variables[2] = u[0] - - potassium_channel_g_K = 36.0 - - f[0] = algebraic_variables[2]-potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computed_constants[0])-0.0 - - -def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[2] - - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[2] = 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] - - algebraic_variables[10] = u[0] - - f[0] = algebraic_variables[10]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 - - -def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[10] - - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[10] = 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] - - algebraic_variables[11] = u[0] - - f[0] = algebraic_variables[11]-0.125*exp(states[0]/80.0)-0.0 - - -def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[11] - - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[11] = 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] - - rates[3] = u[0] - - f[0] = rates[3]-(algebraic_variables[10]*(1.0-states[3])-algebraic_variables[11]*states[3])-0.0 - - -def find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[3] - - u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[3] = u[0] - - -def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 - rates[0] = 0.0 - rates[1] = 0.0 - rates[2] = 0.0 - rates[3] = 0.0 - algebraic_variables[0] = 0.0 - algebraic_variables[1] = 0.0 - algebraic_variables[2] = 0.0 - algebraic_variables[3] = 0.0 - algebraic_variables[4] = 0.0 - algebraic_variables[5] = 0.0 - algebraic_variables[7] = 0.0 - algebraic_variables[8] = 0.0 - algebraic_variables[9] = 0.0 - algebraic_variables[10] = 0.0 - algebraic_variables[11] = 0.0 - - -def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): - membrane_E_R = 0.0 - computed_constants[0] = membrane_E_R+12.0 - - -def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - algebraic_variables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - algebraic_variables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.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 deleted file mode 100644 index 35de3cb1bc..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.c +++ /dev/null @@ -1,575 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.7.0. */ - -#include "model.dae.for.tracking.untracked.constants.with.externals.h" - -#include -#include - -const char VERSION[] = "0.8.0"; -const char LIBCELLML_VERSION[] = "0.7.0"; - -const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 1; -const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_VARIABLE_COUNT = 11; -const size_t EXTERNAL_VARIABLE_COUNT = 1; - -const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; - -const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane"}, - {"h", "dimensionless", "sodium_channel_h_gate"}, - {"m", "dimensionless", "sodium_channel_m_gate"}, - {"n", "dimensionless", "potassium_channel_n_gate"} -}; - -const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane"} -}; - -const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_K", "millivolt", "potassium_channel"} -}; - -const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane"}, - {"i_L", "microA_per_cm2", "leakage_current"}, - {"i_K", "microA_per_cm2", "potassium_channel"}, - {"E_L", "millivolt", "leakage_current"}, - {"E_Na", "millivolt", "sodium_channel"}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate"} -}; - -const VariableInfo EXTERNAL_VARIABLE_INFO[] = { - {"i_Na", "microA_per_cm2", "sodium_channel"} -}; - -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; -} - -double * createExternalVariablesArray() -{ - double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - - for (size_t i = 0; i < EXTERNAL_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; - double *externalVariables; -} 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[0] = u[0]; - - f[0] = algebraicVariables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; -} - -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[0] = u[0]; - - f[0] = rates[0]-(-(-algebraicVariables[0]+externalVariables[0]+algebraicVariables[2]+algebraicVariables[1])/constants[0])-0.0; -} - -void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[0]; - - nlaSolve(objectiveFunction1, u, 1, &rfi); - - rates[0] = u[0]; -} - -void objectiveFunction2(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[3] = u[0]; - - double membrane_E_R = 0.0; - - f[0] = algebraicVariables[3]-(membrane_E_R-10.613)-0.0; -} - -void findRoot2(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[3]; - - nlaSolve(objectiveFunction2, u, 1, &rfi); - - algebraicVariables[3] = u[0]; -} - -void objectiveFunction3(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[1] = u[0]; - - double leakage_current_g_L = 0.3; - - f[0] = algebraicVariables[1]-leakage_current_g_L*(states[0]-algebraicVariables[3])-0.0; -} - -void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[1]; - - nlaSolve(objectiveFunction3, u, 1, &rfi); - - algebraicVariables[1] = u[0]; -} - -void objectiveFunction4(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[4] = u[0]; - - double membrane_E_R = 0.0; - - f[0] = algebraicVariables[4]-(membrane_E_R-115.0)-0.0; -} - -void findRoot4(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[4]; - - nlaSolve(objectiveFunction4, u, 1, &rfi); - - algebraicVariables[4] = u[0]; -} - -void objectiveFunction6(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[6] = u[0]; - - f[0] = algebraicVariables[6]-4.0*exp(states[0]/18.0)-0.0; -} - -void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[2] = u[0]; - - f[0] = rates[2]-(algebraicVariables[5]*(1.0-states[2])-algebraicVariables[6]*states[2])-0.0; -} - -void findRoot7(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[2]; - - nlaSolve(objectiveFunction7, u, 1, &rfi); - - rates[2] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[7] = u[0]; - - f[0] = algebraicVariables[7]-0.07*exp(states[0]/20.0)-0.0; -} - -void findRoot8(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[7]; - - nlaSolve(objectiveFunction8, u, 1, &rfi); - - algebraicVariables[7] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[8] = u[0]; - - f[0] = algebraicVariables[8]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; -} - -void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[8]; - - nlaSolve(objectiveFunction9, u, 1, &rfi); - - algebraicVariables[8] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[1] = u[0]; - - f[0] = rates[1]-(algebraicVariables[7]*(1.0-states[1])-algebraicVariables[8]*states[1])-0.0; -} - -void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[1]; - - nlaSolve(objectiveFunction10, u, 1, &rfi); - - rates[1] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[2] = u[0]; - - double potassium_channel_g_K = 36.0; - - f[0] = algebraicVariables[2]-potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computedConstants[0])-0.0; -} - -void findRoot11(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[2]; - - nlaSolve(objectiveFunction11, u, 1, &rfi); - - algebraicVariables[2] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[9] = u[0]; - - f[0] = algebraicVariables[9]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; -} - -void findRoot12(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[9]; - - nlaSolve(objectiveFunction12, u, 1, &rfi); - - algebraicVariables[9] = u[0]; -} - -void objectiveFunction13(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[10] = u[0]; - - f[0] = algebraicVariables[10]-0.125*exp(states[0]/80.0)-0.0; -} - -void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[10]; - - nlaSolve(objectiveFunction13, u, 1, &rfi); - - algebraicVariables[10] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[3] = u[0]; - - f[0] = rates[3]-(algebraicVariables[9]*(1.0-states[3])-algebraicVariables[10]*states[3])-0.0; -} - -void findRoot14(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[3]; - - nlaSolve(objectiveFunction14, u, 1, &rfi); - - rates[3] = u[0]; -} - -void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; - rates[0] = 0.0; - rates[1] = 0.0; - rates[2] = 0.0; - rates[3] = 0.0; - constants[0] = 1.0; - algebraicVariables[0] = 0.0; - algebraicVariables[1] = 0.0; - algebraicVariables[2] = 0.0; - algebraicVariables[3] = 0.0; - algebraicVariables[4] = 0.0; - algebraicVariables[6] = 0.0; - algebraicVariables[7] = 0.0; - algebraicVariables[8] = 0.0; - algebraicVariables[9] = 0.0; - algebraicVariables[10] = 0.0; -} - -void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - double membrane_E_R = 0.0; - computedConstants[0] = membrane_E_R+12.0; -} - -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) -{ - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); -} - -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) -{ - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); -} 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 deleted file mode 100644 index 645bd43e80..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.py +++ /dev/null @@ -1,490 +0,0 @@ -# The content of this file was generated using the Python profile of libCellML 0.7.0. - -from enum import Enum -from math import * - - -__version__ = "0.8.0" -LIBCELLML_VERSION = "0.7.0" - -STATE_COUNT = 4 -CONSTANT_COUNT = 1 -COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_VARIABLE_COUNT = 11 -EXTERNAL_VARIABLE_COUNT = 1 - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} - -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane"}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} -] - -CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"} -] - -COMPUTED_CONSTANT_INFO = [ - {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} -] - -ALGEBRAIC_VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} -] - -EXTERNAL_VARIABLE_INFO = [ - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} -] - - -def leq_func(x, y): - return 1.0 if x <= y else 0.0 - - -def geq_func(x, y): - return 1.0 if x >= y else 0.0 - - -def and_func(x, y): - return 1.0 if bool(x) & bool(y) else 0.0 - - -def create_states_array(): - return [nan]*STATE_COUNT - - -def create_constants_array(): - return [nan]*CONSTANT_COUNT - - -def create_computed_constants_array(): - return [nan]*COMPUTED_CONSTANT_COUNT - - -def create_algebraic_variables_array(): - return [nan]*ALGEBRAIC_VARIABLE_COUNT - - -def create_external_variables_array(): - return [nan]*EXTERNAL_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] - external_variables = data[6] - - algebraic_variables[0] = u[0] - - f[0] = algebraic_variables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[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] - external_variables = data[6] - - rates[0] = u[0] - - f[0] = rates[0]-(-(-algebraic_variables[0]+external_variables[0]+algebraic_variables[2]+algebraic_variables[1])/constants[0])-0.0 - - -def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[0] - - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[0] = u[0] - - -def objective_function_2(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[3] = u[0] - - membrane_E_R = 0.0 - - f[0] = algebraic_variables[3]-(membrane_E_R-10.613)-0.0 - - -def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[3] - - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[3] = u[0] - - -def objective_function_3(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[1] = u[0] - - leakage_current_g_L = 0.3 - - f[0] = algebraic_variables[1]-leakage_current_g_L*(states[0]-algebraic_variables[3])-0.0 - - -def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[1] - - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[1] = u[0] - - -def objective_function_4(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[4] = u[0] - - membrane_E_R = 0.0 - - f[0] = algebraic_variables[4]-(membrane_E_R-115.0)-0.0 - - -def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[4] - - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[4] = u[0] - - -def objective_function_6(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[6] = u[0] - - f[0] = algebraic_variables[6]-4.0*exp(states[0]/18.0)-0.0 - - -def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[6] - - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[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] - external_variables = data[6] - - rates[2] = u[0] - - f[0] = rates[2]-(algebraic_variables[5]*(1.0-states[2])-algebraic_variables[6]*states[2])-0.0 - - -def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[2] - - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[2] = 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] - external_variables = data[6] - - algebraic_variables[7] = u[0] - - f[0] = algebraic_variables[7]-0.07*exp(states[0]/20.0)-0.0 - - -def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[7] - - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[7] = 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] - external_variables = data[6] - - algebraic_variables[8] = u[0] - - f[0] = algebraic_variables[8]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 - - -def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[8] - - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[8] = 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] - external_variables = data[6] - - rates[1] = u[0] - - f[0] = rates[1]-(algebraic_variables[7]*(1.0-states[1])-algebraic_variables[8]*states[1])-0.0 - - -def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[1] - - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[1] = 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] - external_variables = data[6] - - algebraic_variables[2] = u[0] - - potassium_channel_g_K = 36.0 - - f[0] = algebraic_variables[2]-potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computed_constants[0])-0.0 - - -def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[2] - - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[2] = 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] - external_variables = data[6] - - algebraic_variables[9] = u[0] - - f[0] = algebraic_variables[9]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 - - -def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[9] - - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[9] = u[0] - - -def objective_function_13(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[10] = u[0] - - f[0] = algebraic_variables[10]-0.125*exp(states[0]/80.0)-0.0 - - -def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[10] - - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[10] = 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] - external_variables = data[6] - - rates[3] = u[0] - - f[0] = rates[3]-(algebraic_variables[9]*(1.0-states[3])-algebraic_variables[10]*states[3])-0.0 - - -def find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[3] - - u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[3] = u[0] - - -def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 - rates[0] = 0.0 - rates[1] = 0.0 - rates[2] = 0.0 - rates[3] = 0.0 - constants[0] = 1.0 - algebraic_variables[0] = 0.0 - algebraic_variables[1] = 0.0 - algebraic_variables[2] = 0.0 - algebraic_variables[3] = 0.0 - algebraic_variables[4] = 0.0 - algebraic_variables[6] = 0.0 - algebraic_variables[7] = 0.0 - algebraic_variables[8] = 0.0 - algebraic_variables[9] = 0.0 - algebraic_variables[10] = 0.0 - - -def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): - membrane_E_R = 0.0 - computed_constants[0] = membrane_E_R+12.0 - - -def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) 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 deleted file mode 100644 index dc31eb6e05..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.c +++ /dev/null @@ -1,572 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.7.0. */ - -#include "model.dae.for.tracking.untracked.variables.h" - -#include -#include - -const char VERSION[] = "0.8.0"; -const char LIBCELLML_VERSION[] = "0.7.0"; - -const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_VARIABLE_COUNT = 11; - -const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; - -const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane"}, - {"h", "dimensionless", "sodium_channel_h_gate"}, - {"m", "dimensionless", "sodium_channel_m_gate"}, - {"n", "dimensionless", "potassium_channel_n_gate"} -}; - -const VariableInfo CONSTANT_INFO[] = { -}; - -const VariableInfo COMPUTED_CONSTANT_INFO[] = { -}; - -const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane"}, - {"i_L", "microA_per_cm2", "leakage_current"}, - {"i_K", "microA_per_cm2", "potassium_channel"}, - {"i_Na", "microA_per_cm2", "sodium_channel"}, - {"E_L", "millivolt", "leakage_current"}, - {"E_Na", "millivolt", "sodium_channel"}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate"} -}; - -double * createStatesArray() -{ - 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] = algebraicVariables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; -} - -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *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; - - rates[0] = u[0]; - - double membrane_Cm = 1.0; - - f[0] = rates[0]-(-(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/membrane_Cm)-0.0; -} - -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] = rates[0]; - - nlaSolve(objectiveFunction1, u, 1, &rfi); - - rates[0] = u[0]; -} - -void objectiveFunction2(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[4] = u[0]; - - double membrane_E_R = 0.0; - - f[0] = algebraicVariables[4]-(membrane_E_R-10.613)-0.0; -} - -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[4]; - - nlaSolve(objectiveFunction2, u, 1, &rfi); - - algebraicVariables[4] = 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[1] = u[0]; - - double leakage_current_g_L = 0.3; - - f[0] = algebraicVariables[1]-leakage_current_g_L*(states[0]-algebraicVariables[4])-0.0; -} - -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[1]; - - nlaSolve(objectiveFunction3, u, 1, &rfi); - - algebraicVariables[1] = u[0]; -} - -void objectiveFunction4(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[5] = u[0]; - - double membrane_E_R = 0.0; - - f[0] = algebraicVariables[5]-(membrane_E_R-115.0)-0.0; -} - -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[5]; - - nlaSolve(objectiveFunction4, u, 1, &rfi); - - algebraicVariables[5] = 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[3] = u[0]; - - double sodium_channel_g_Na = 120.0; - - f[0] = algebraicVariables[3]-sodium_channel_g_Na*pow(states[2], 3.0)*states[1]*(states[0]-algebraicVariables[5])-0.0; -} - -void findRoot5(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; - double u[1]; - - u[0] = algebraicVariables[3]; - - nlaSolve(objectiveFunction5, u, 1, &rfi); - - algebraicVariables[3] = 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] = algebraicVariables[6]-4.0*exp(states[0]/18.0)-0.0; -} - -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; - - rates[2] = u[0]; - - double sodium_channel_m_gate_alpha_m = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - - f[0] = rates[2]-(sodium_channel_m_gate_alpha_m*(1.0-states[2])-algebraicVariables[6]*states[2])-0.0; -} - -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] = rates[2]; - - nlaSolve(objectiveFunction7, u, 1, &rfi); - - rates[2] = 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[7] = u[0]; - - f[0] = algebraicVariables[7]-0.07*exp(states[0]/20.0)-0.0; -} - -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[7]; - - nlaSolve(objectiveFunction8, u, 1, &rfi); - - algebraicVariables[7] = 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[8] = u[0]; - - f[0] = algebraicVariables[8]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; -} - -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[8]; - - nlaSolve(objectiveFunction9, u, 1, &rfi); - - algebraicVariables[8] = 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; - - rates[1] = u[0]; - - f[0] = rates[1]-(algebraicVariables[7]*(1.0-states[1])-algebraicVariables[8]*states[1])-0.0; -} - -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] = rates[1]; - - nlaSolve(objectiveFunction10, u, 1, &rfi); - - rates[1] = 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[2] = u[0]; - - double potassium_channel_g_K = 36.0; - double membrane_E_R = 0.0; - double potassium_channel_E_K = membrane_E_R+12.0; - - f[0] = algebraicVariables[2]-potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-potassium_channel_E_K)-0.0; -} - -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[2]; - - nlaSolve(objectiveFunction11, u, 1, &rfi); - - algebraicVariables[2] = 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[9] = u[0]; - - f[0] = algebraicVariables[9]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; -} - -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[9]; - - nlaSolve(objectiveFunction12, u, 1, &rfi); - - algebraicVariables[9] = u[0]; -} - -void objectiveFunction13(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - - algebraicVariables[10] = u[0]; - - f[0] = algebraicVariables[10]-0.125*exp(states[0]/80.0)-0.0; -} - -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[10]; - - nlaSolve(objectiveFunction13, u, 1, &rfi); - - algebraicVariables[10] = 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; - - rates[3] = u[0]; - - f[0] = rates[3]-(algebraicVariables[9]*(1.0-states[3])-algebraicVariables[10]*states[3])-0.0; -} - -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] = rates[3]; - - nlaSolve(objectiveFunction14, u, 1, &rfi); - - rates[3] = u[0]; -} - -void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; - rates[0] = 0.0; - rates[1] = 0.0; - rates[2] = 0.0; - rates[3] = 0.0; - algebraicVariables[0] = 0.0; - algebraicVariables[1] = 0.0; - algebraicVariables[2] = 0.0; - algebraicVariables[3] = 0.0; - algebraicVariables[4] = 0.0; - algebraicVariables[5] = 0.0; - algebraicVariables[6] = 0.0; - algebraicVariables[7] = 0.0; - algebraicVariables[8] = 0.0; - algebraicVariables[9] = 0.0; - algebraicVariables[10] = 0.0; -} - -void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ -} - -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); -} - -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); -} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.py deleted file mode 100644 index 6893dd63e8..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.py +++ /dev/null @@ -1,493 +0,0 @@ -# The content of this file was generated using the Python profile of libCellML 0.7.0. - -from enum import Enum -from math import * - - -__version__ = "0.8.0" -LIBCELLML_VERSION = "0.7.0" - -STATE_COUNT = 4 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_VARIABLE_COUNT = 11 - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} - -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane"}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} -] - -CONSTANT_INFO = [ -] - -COMPUTED_CONSTANT_INFO = [ -] - -ALGEBRAIC_VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} -] - - -def leq_func(x, y): - return 1.0 if x <= y else 0.0 - - -def geq_func(x, y): - return 1.0 if x >= y else 0.0 - - -def and_func(x, y): - return 1.0 if bool(x) & bool(y) else 0.0 - - -def create_states_array(): - return [nan]*STATE_COUNT - - -def create_constants_array(): - return [nan]*CONSTANT_COUNT - - -def create_computed_constants_array(): - return [nan]*COMPUTED_CONSTANT_COUNT - - -def create_algebraic_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] - - algebraic_variables[0] = u[0] - - f[0] = algebraic_variables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - rates[0] = u[0] - - membrane_Cm = 1.0 - - f[0] = rates[0]-(-(-algebraic_variables[0]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1])/membrane_Cm)-0.0 - - -def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[0] - - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[0] = u[0] - - -def objective_function_2(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - - algebraic_variables[4] = u[0] - - membrane_E_R = 0.0 - - f[0] = algebraic_variables[4]-(membrane_E_R-10.613)-0.0 - - -def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[4] - - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[4] = 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] - - algebraic_variables[1] = u[0] - - leakage_current_g_L = 0.3 - - f[0] = algebraic_variables[1]-leakage_current_g_L*(states[0]-algebraic_variables[4])-0.0 - - -def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[1] - - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[1] = u[0] - - -def objective_function_4(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - - algebraic_variables[5] = u[0] - - membrane_E_R = 0.0 - - f[0] = algebraic_variables[5]-(membrane_E_R-115.0)-0.0 - - -def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[5] - - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[5] = 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] - - algebraic_variables[3] = u[0] - - sodium_channel_g_Na = 120.0 - - f[0] = algebraic_variables[3]-sodium_channel_g_Na*pow(states[2], 3.0)*states[1]*(states[0]-algebraic_variables[5])-0.0 - - -def find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[3] - - u = nla_solve(objective_function_5, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[3] = 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] - - algebraic_variables[6] = u[0] - - f[0] = algebraic_variables[6]-4.0*exp(states[0]/18.0)-0.0 - - -def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[6] - - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - rates[2] = u[0] - - sodium_channel_m_gate_alpha_m = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - - f[0] = rates[2]-(sodium_channel_m_gate_alpha_m*(1.0-states[2])-algebraic_variables[6]*states[2])-0.0 - - -def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[2] - - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[2] = 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] - - algebraic_variables[7] = u[0] - - f[0] = algebraic_variables[7]-0.07*exp(states[0]/20.0)-0.0 - - -def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[7] - - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[7] = 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] - - algebraic_variables[8] = u[0] - - f[0] = algebraic_variables[8]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 - - -def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[8] - - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[8] = 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] - - rates[1] = u[0] - - f[0] = rates[1]-(algebraic_variables[7]*(1.0-states[1])-algebraic_variables[8]*states[1])-0.0 - - -def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[1] - - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[1] = 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] - - algebraic_variables[2] = u[0] - - potassium_channel_g_K = 36.0 - membrane_E_R = 0.0 - potassium_channel_E_K = membrane_E_R+12.0 - - f[0] = algebraic_variables[2]-potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-potassium_channel_E_K)-0.0 - - -def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[2] - - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[2] = 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] - - algebraic_variables[9] = u[0] - - f[0] = algebraic_variables[9]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 - - -def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[9] - - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[9] = u[0] - - -def objective_function_13(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - - algebraic_variables[10] = u[0] - - f[0] = algebraic_variables[10]-0.125*exp(states[0]/80.0)-0.0 - - -def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[10] - - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[10] = 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] - - rates[3] = u[0] - - f[0] = rates[3]-(algebraic_variables[9]*(1.0-states[3])-algebraic_variables[10]*states[3])-0.0 - - -def find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[3] - - u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[3] = u[0] - - -def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 - rates[0] = 0.0 - rates[1] = 0.0 - rates[2] = 0.0 - rates[3] = 0.0 - algebraic_variables[0] = 0.0 - algebraic_variables[1] = 0.0 - algebraic_variables[2] = 0.0 - algebraic_variables[3] = 0.0 - algebraic_variables[4] = 0.0 - algebraic_variables[5] = 0.0 - algebraic_variables[6] = 0.0 - algebraic_variables[7] = 0.0 - algebraic_variables[8] = 0.0 - algebraic_variables[9] = 0.0 - algebraic_variables[10] = 0.0 - - -def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): - pass - - -def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(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_4(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(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_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.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 deleted file mode 100644 index afb8302c95..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.c +++ /dev/null @@ -1,575 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.7.0. */ - -#include "model.dae.for.tracking.untracked.variables.with.externals.h" - -#include -#include - -const char VERSION[] = "0.8.0"; -const char LIBCELLML_VERSION[] = "0.7.0"; - -const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 1; -const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_VARIABLE_COUNT = 11; -const size_t EXTERNAL_VARIABLE_COUNT = 1; - -const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; - -const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane"}, - {"h", "dimensionless", "sodium_channel_h_gate"}, - {"m", "dimensionless", "sodium_channel_m_gate"}, - {"n", "dimensionless", "potassium_channel_n_gate"} -}; - -const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane"} -}; - -const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_K", "millivolt", "potassium_channel"} -}; - -const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane"}, - {"i_L", "microA_per_cm2", "leakage_current"}, - {"i_K", "microA_per_cm2", "potassium_channel"}, - {"E_L", "millivolt", "leakage_current"}, - {"E_Na", "millivolt", "sodium_channel"}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate"} -}; - -const VariableInfo EXTERNAL_VARIABLE_INFO[] = { - {"i_Na", "microA_per_cm2", "sodium_channel"} -}; - -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; -} - -double * createExternalVariablesArray() -{ - double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - - for (size_t i = 0; i < EXTERNAL_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; - double *externalVariables; -} 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[0] = u[0]; - - f[0] = algebraicVariables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; -} - -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[0] = u[0]; - - f[0] = rates[0]-(-(-algebraicVariables[0]+externalVariables[0]+algebraicVariables[2]+algebraicVariables[1])/constants[0])-0.0; -} - -void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[0]; - - nlaSolve(objectiveFunction1, u, 1, &rfi); - - rates[0] = u[0]; -} - -void objectiveFunction2(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[3] = u[0]; - - double membrane_E_R = 0.0; - - f[0] = algebraicVariables[3]-(membrane_E_R-10.613)-0.0; -} - -void findRoot2(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[3]; - - nlaSolve(objectiveFunction2, u, 1, &rfi); - - algebraicVariables[3] = u[0]; -} - -void objectiveFunction3(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[1] = u[0]; - - double leakage_current_g_L = 0.3; - - f[0] = algebraicVariables[1]-leakage_current_g_L*(states[0]-algebraicVariables[3])-0.0; -} - -void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[1]; - - nlaSolve(objectiveFunction3, u, 1, &rfi); - - algebraicVariables[1] = u[0]; -} - -void objectiveFunction4(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[4] = u[0]; - - double membrane_E_R = 0.0; - - f[0] = algebraicVariables[4]-(membrane_E_R-115.0)-0.0; -} - -void findRoot4(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[4]; - - nlaSolve(objectiveFunction4, u, 1, &rfi); - - algebraicVariables[4] = u[0]; -} - -void objectiveFunction6(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[6] = u[0]; - - f[0] = algebraicVariables[6]-4.0*exp(states[0]/18.0)-0.0; -} - -void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[2] = u[0]; - - f[0] = rates[2]-(algebraicVariables[5]*(1.0-states[2])-algebraicVariables[6]*states[2])-0.0; -} - -void findRoot7(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[2]; - - nlaSolve(objectiveFunction7, u, 1, &rfi); - - rates[2] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[7] = u[0]; - - f[0] = algebraicVariables[7]-0.07*exp(states[0]/20.0)-0.0; -} - -void findRoot8(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[7]; - - nlaSolve(objectiveFunction8, u, 1, &rfi); - - algebraicVariables[7] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[8] = u[0]; - - f[0] = algebraicVariables[8]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; -} - -void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[8]; - - nlaSolve(objectiveFunction9, u, 1, &rfi); - - algebraicVariables[8] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[1] = u[0]; - - f[0] = rates[1]-(algebraicVariables[7]*(1.0-states[1])-algebraicVariables[8]*states[1])-0.0; -} - -void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[1]; - - nlaSolve(objectiveFunction10, u, 1, &rfi); - - rates[1] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[2] = u[0]; - - double potassium_channel_g_K = 36.0; - - f[0] = algebraicVariables[2]-potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computedConstants[0])-0.0; -} - -void findRoot11(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[2]; - - nlaSolve(objectiveFunction11, u, 1, &rfi); - - algebraicVariables[2] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[9] = u[0]; - - f[0] = algebraicVariables[9]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; -} - -void findRoot12(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[9]; - - nlaSolve(objectiveFunction12, u, 1, &rfi); - - algebraicVariables[9] = u[0]; -} - -void objectiveFunction13(double *u, double *f, void *data) -{ - double voi = ((RootFindingInfo *) data)->voi; - double *states = ((RootFindingInfo *) data)->states; - double *rates = ((RootFindingInfo *) data)->rates; - double *constants = ((RootFindingInfo *) data)->constants; - double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - algebraicVariables[10] = u[0]; - - f[0] = algebraicVariables[10]-0.125*exp(states[0]/80.0)-0.0; -} - -void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = algebraicVariables[10]; - - nlaSolve(objectiveFunction13, u, 1, &rfi); - - algebraicVariables[10] = 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; - double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - - rates[3] = u[0]; - - f[0] = rates[3]-(algebraicVariables[9]*(1.0-states[3])-algebraicVariables[10]*states[3])-0.0; -} - -void findRoot14(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) -{ - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; - double u[1]; - - u[0] = rates[3]; - - nlaSolve(objectiveFunction14, u, 1, &rfi); - - rates[3] = u[0]; -} - -void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; - rates[0] = 0.0; - rates[1] = 0.0; - rates[2] = 0.0; - rates[3] = 0.0; - constants[0] = 1.0; - algebraicVariables[0] = 0.0; - algebraicVariables[1] = 0.0; - algebraicVariables[2] = 0.0; - algebraicVariables[3] = 0.0; - algebraicVariables[4] = 0.0; - algebraicVariables[6] = 0.0; - algebraicVariables[7] = 0.0; - algebraicVariables[8] = 0.0; - algebraicVariables[9] = 0.0; - algebraicVariables[10] = 0.0; -} - -void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - double membrane_E_R = 0.0; - computedConstants[0] = membrane_E_R+12.0; -} - -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) -{ - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); -} - -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) -{ - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); -} 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 deleted file mode 100644 index 645bd43e80..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.py +++ /dev/null @@ -1,490 +0,0 @@ -# The content of this file was generated using the Python profile of libCellML 0.7.0. - -from enum import Enum -from math import * - - -__version__ = "0.8.0" -LIBCELLML_VERSION = "0.7.0" - -STATE_COUNT = 4 -CONSTANT_COUNT = 1 -COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_VARIABLE_COUNT = 11 -EXTERNAL_VARIABLE_COUNT = 1 - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} - -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane"}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} -] - -CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"} -] - -COMPUTED_CONSTANT_INFO = [ - {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} -] - -ALGEBRAIC_VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} -] - -EXTERNAL_VARIABLE_INFO = [ - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} -] - - -def leq_func(x, y): - return 1.0 if x <= y else 0.0 - - -def geq_func(x, y): - return 1.0 if x >= y else 0.0 - - -def and_func(x, y): - return 1.0 if bool(x) & bool(y) else 0.0 - - -def create_states_array(): - return [nan]*STATE_COUNT - - -def create_constants_array(): - return [nan]*CONSTANT_COUNT - - -def create_computed_constants_array(): - return [nan]*COMPUTED_CONSTANT_COUNT - - -def create_algebraic_variables_array(): - return [nan]*ALGEBRAIC_VARIABLE_COUNT - - -def create_external_variables_array(): - return [nan]*EXTERNAL_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] - external_variables = data[6] - - algebraic_variables[0] = u[0] - - f[0] = algebraic_variables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[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] - external_variables = data[6] - - rates[0] = u[0] - - f[0] = rates[0]-(-(-algebraic_variables[0]+external_variables[0]+algebraic_variables[2]+algebraic_variables[1])/constants[0])-0.0 - - -def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[0] - - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[0] = u[0] - - -def objective_function_2(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[3] = u[0] - - membrane_E_R = 0.0 - - f[0] = algebraic_variables[3]-(membrane_E_R-10.613)-0.0 - - -def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[3] - - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[3] = u[0] - - -def objective_function_3(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[1] = u[0] - - leakage_current_g_L = 0.3 - - f[0] = algebraic_variables[1]-leakage_current_g_L*(states[0]-algebraic_variables[3])-0.0 - - -def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[1] - - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[1] = u[0] - - -def objective_function_4(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[4] = u[0] - - membrane_E_R = 0.0 - - f[0] = algebraic_variables[4]-(membrane_E_R-115.0)-0.0 - - -def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[4] - - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[4] = u[0] - - -def objective_function_6(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[6] = u[0] - - f[0] = algebraic_variables[6]-4.0*exp(states[0]/18.0)-0.0 - - -def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[6] - - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[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] - external_variables = data[6] - - rates[2] = u[0] - - f[0] = rates[2]-(algebraic_variables[5]*(1.0-states[2])-algebraic_variables[6]*states[2])-0.0 - - -def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[2] - - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[2] = 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] - external_variables = data[6] - - algebraic_variables[7] = u[0] - - f[0] = algebraic_variables[7]-0.07*exp(states[0]/20.0)-0.0 - - -def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[7] - - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[7] = 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] - external_variables = data[6] - - algebraic_variables[8] = u[0] - - f[0] = algebraic_variables[8]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 - - -def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[8] - - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[8] = 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] - external_variables = data[6] - - rates[1] = u[0] - - f[0] = rates[1]-(algebraic_variables[7]*(1.0-states[1])-algebraic_variables[8]*states[1])-0.0 - - -def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[1] - - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[1] = 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] - external_variables = data[6] - - algebraic_variables[2] = u[0] - - potassium_channel_g_K = 36.0 - - f[0] = algebraic_variables[2]-potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computed_constants[0])-0.0 - - -def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[2] - - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[2] = 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] - external_variables = data[6] - - algebraic_variables[9] = u[0] - - f[0] = algebraic_variables[9]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 - - -def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[9] - - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[9] = u[0] - - -def objective_function_13(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - external_variables = data[6] - - algebraic_variables[10] = u[0] - - f[0] = algebraic_variables[10]-0.125*exp(states[0]/80.0)-0.0 - - -def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = algebraic_variables[10] - - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - algebraic_variables[10] = 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] - external_variables = data[6] - - rates[3] = u[0] - - f[0] = rates[3]-(algebraic_variables[9]*(1.0-states[3])-algebraic_variables[10]*states[3])-0.0 - - -def find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): - u = [nan]*1 - - u[0] = rates[3] - - u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - - rates[3] = u[0] - - -def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 - rates[0] = 0.0 - rates[1] = 0.0 - rates[2] = 0.0 - rates[3] = 0.0 - constants[0] = 1.0 - algebraic_variables[0] = 0.0 - algebraic_variables[1] = 0.0 - algebraic_variables[2] = 0.0 - algebraic_variables[3] = 0.0 - algebraic_variables[4] = 0.0 - algebraic_variables[6] = 0.0 - algebraic_variables[7] = 0.0 - algebraic_variables[8] = 0.0 - algebraic_variables[9] = 0.0 - algebraic_variables[10] = 0.0 - - -def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): - membrane_E_R = 0.0 - computed_constants[0] = membrane_E_R+12.0 - - -def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py deleted file mode 100644 index 866ed6ccc8..0000000000 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ /dev/null @@ -1,540 +0,0 @@ -# The content of this file was generated using the Python profile of libCellML 0.7.0. - -from enum import Enum -from math import * - - -__version__ = "0.8.0" -LIBCELLML_VERSION = "0.7.0" - -STATE_COUNT = 4 -CONSTANT_COUNT = 5 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_VARIABLE_COUNT = 13 - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} - -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane"}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} -] - -CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, - {"name": "E_R", "units": "millivolt", "component": "membrane"}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} -] - -COMPUTED_CONSTANT_INFO = [ -] - -ALGEBRAIC_VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel"}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} -] - - -def leq_func(x, y): - return 1.0 if x <= y else 0.0 - - -def geq_func(x, y): - return 1.0 if x >= y else 0.0 - - -def and_func(x, y): - return 1.0 if bool(x) & bool(y) else 0.0 - - -def create_states_array(): - return [nan]*STATE_COUNT - - -def create_constants_array(): - return [nan]*CONSTANT_COUNT - - -def create_computed_constants_array(): - return [nan]*COMPUTED_CONSTANT_COUNT - - -def create_algebraic_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] - - algebraic_variables[0] = u[0] - - f[0] = algebraic_variables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - rates[0] = u[0] - - f[0] = rates[0]-(-(-algebraic_variables[0]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1])/constants[0])-0.0 - - -def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[0] - - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[0] = u[0] - - -def objective_function_2(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - - algebraic_variables[4] = u[0] - - f[0] = algebraic_variables[4]-(constants[1]-10.613)-0.0 - - -def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[4] - - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[4] = 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] - - algebraic_variables[1] = u[0] - - f[0] = algebraic_variables[1]-constants[2]*(states[0]-algebraic_variables[4])-0.0 - - -def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[1] - - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[1] = u[0] - - -def objective_function_4(u, f, data): - voi = data[0] - states = data[1] - rates = data[2] - constants = data[3] - computed_constants = data[4] - algebraic_variables = data[5] - - algebraic_variables[5] = u[0] - - f[0] = algebraic_variables[5]-(constants[1]-115.0)-0.0 - - -def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[5] - - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[5] = 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] - - algebraic_variables[3] = u[0] - - f[0] = algebraic_variables[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic_variables[5])-0.0 - - -def find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[3] - - u = nla_solve(objective_function_5, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[3] = 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] - - algebraic_variables[6] = u[0] - - f[0] = algebraic_variables[6]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0 - - -def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[6] - - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[7] = u[0] - - f[0] = algebraic_variables[7]-4.0*exp(states[0]/18.0)-0.0 - - -def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[7] - - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - rates[2] = u[0] - - f[0] = rates[2]-(algebraic_variables[6]*(1.0-states[2])-algebraic_variables[7]*states[2])-0.0 - - -def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[2] - - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[2] = 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] - - algebraic_variables[8] = u[0] - - f[0] = algebraic_variables[8]-0.07*exp(states[0]/20.0)-0.0 - - -def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[8] - - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[8] = 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] - - algebraic_variables[9] = u[0] - - f[0] = algebraic_variables[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 - - -def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[9] - - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[9] = 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] - - rates[1] = u[0] - - f[0] = rates[1]-(algebraic_variables[8]*(1.0-states[1])-algebraic_variables[9]*states[1])-0.0 - - -def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[1] - - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[1] = 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] - - algebraic_variables[10] = u[0] - - f[0] = algebraic_variables[10]-(constants[1]+12.0)-0.0 - - -def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[10] - - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[10] = 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] - - algebraic_variables[2] = u[0] - - f[0] = algebraic_variables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-algebraic_variables[10])-0.0 - - -def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[2] - - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[2] = 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] - - algebraic_variables[11] = u[0] - - f[0] = algebraic_variables[11]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 - - -def find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[11] - - u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[11] = 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] - - algebraic_variables[12] = u[0] - - f[0] = algebraic_variables[12]-0.125*exp(states[0]/80.0)-0.0 - - -def find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[12] - - u = nla_solve(objective_function_15, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[12] = 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] - - rates[3] = u[0] - - f[0] = rates[3]-(algebraic_variables[11]*(1.0-states[3])-algebraic_variables[12]*states[3])-0.0 - - -def find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = rates[3] - - u = nla_solve(objective_function_16, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - rates[3] = u[0] - - -def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 - rates[0] = 0.0 - rates[1] = 0.0 - rates[2] = 0.0 - rates[3] = 0.0 - constants[0] = 1.0 - constants[1] = 0.0 - constants[2] = 0.3 - constants[3] = 120.0 - constants[4] = 36.0 - algebraic_variables[0] = 0.0 - algebraic_variables[1] = 0.0 - algebraic_variables[2] = 0.0 - algebraic_variables[3] = 0.0 - algebraic_variables[4] = 0.0 - algebraic_variables[5] = 0.0 - algebraic_variables[6] = 0.0 - algebraic_variables[7] = 0.0 - algebraic_variables[8] = 0.0 - algebraic_variables[9] = 0.0 - algebraic_variables[10] = 0.0 - algebraic_variables[11] = 0.0 - algebraic_variables[12] = 0.0 - - -def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): - pass - - -def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 44e86d3200..5612327a85 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -135,12 +135,12 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); algebraicVariables[0] = constants[2]*(states[0]-computedConstants[0]); algebraicVariables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraicVariables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-externalVariables[0]+algebraicVariables[2]+algebraicVariables[1]+algebraicVariables[0])/constants[0]; + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + rates[0] = (externalVariables[0]-algebraicVariables[2]-algebraicVariables[1]-algebraicVariables[0])/constants[0]; algebraicVariables[4] = 4.0*exp(states[0]/18.0); algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraicVariables[3]*(1.0-states[2])-algebraicVariables[4]*states[2]; 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 f7dab179c9..101d2d751e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -104,12 +104,12 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) algebraic_variables[0] = constants[2]*(states[0]-computed_constants[0]) algebraic_variables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic_variables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-external_variables[0]+algebraic_variables[2]+algebraic_variables[1]+algebraic_variables[0])/constants[0] + external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + rates[0] = (external_variables[0]-algebraic_variables[2]-algebraic_variables[1]-algebraic_variables[0])/constants[0] algebraic_variables[4] = 4.0*exp(states[0]/18.0) algebraic_variables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic_variables[3]*(1.0-states[2])-algebraic_variables[4]*states[2] 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 5728732302..b814badc59 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 @@ -131,7 +131,6 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); algebraicVariables[4] = externalVariables[0]-10.613; @@ -139,7 +138,8 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraicVariables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externalVariables[1]); algebraicVariables[5] = externalVariables[0]-115.0; algebraicVariables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraicVariables[5]); - rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[3]-algebraicVariables[2]-algebraicVariables[1])/constants[0]; algebraicVariables[7] = 4.0*exp(states[0]/18.0); algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraicVariables[6]*(1.0-states[2])-algebraicVariables[7]*states[2]; 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 ad5f60a033..0b4231d91e 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 @@ -101,7 +101,6 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) algebraic_variables[4] = external_variables[0]-10.613 @@ -109,7 +108,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v algebraic_variables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external_variables[1]) algebraic_variables[5] = external_variables[0]-115.0 algebraic_variables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic_variables[5]) - rates[0] = -(-algebraic_variables[0]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1])/constants[0] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[3]-algebraic_variables[2]-algebraic_variables[1])/constants[0] algebraic_variables[7] = 4.0*exp(states[0]/18.0) algebraic_variables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic_variables[6]*(1.0-states[2])-algebraic_variables[7]*states[2] 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 7df7bdaad8..95598b12de 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 @@ -135,11 +135,11 @@ void computeRates(double voi, double *states, double *rates, double *constants, { externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; algebraicVariables[1] = constants[1]*(states[0]-computedConstants[0]); algebraicVariables[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraicVariables[3] = externalVariables[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/externalVariables[0]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[3]-algebraicVariables[2]-algebraicVariables[1])/externalVariables[0]; algebraicVariables[5] = 4.0*exp(states[0]/18.0); algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2]; 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 43ccf1c1fa..5c2c069259 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 @@ -104,11 +104,11 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 algebraic_variables[1] = constants[1]*(states[0]-computed_constants[0]) algebraic_variables[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic_variables[3] = external_variables[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic_variables[0]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1])/external_variables[0] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[3]-algebraic_variables[2]-algebraic_variables[1])/external_variables[0] algebraic_variables[5] = 4.0*exp(states[0]/18.0) algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic_variables[4]*(1.0-states[2])-algebraic_variables[5]*states[2] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 983b6791ed..5bf857bc9d 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 @@ -96,11 +96,11 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 algebraic_variables[1] = constants[2]*(states[0]-computed_constants[0]) algebraic_variables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic_variables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic_variables[0]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1])/constants[0] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[3]-algebraic_variables[2]-algebraic_variables[1])/constants[0] algebraic_variables[5] = 4.0*exp(states[0]/18.0) algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic_variables[4]*(1.0-states[2])-algebraic_variables[5]*states[2] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index e79c815c2d..323780cb09 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 @@ -134,12 +134,12 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; algebraicVariables[1] = constants[2]*(states[0]-computedConstants[0]); algebraicVariables[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computedConstants[2]); externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); algebraicVariables[3] = constants[3]*pow(externalVariables[0], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[3]-algebraicVariables[2]-algebraicVariables[1])/constants[0]; algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); algebraicVariables[6] = 0.07*exp(states[0]/20.0); rates[1] = algebraicVariables[6]*(1.0-states[1])-algebraicVariables[7]*states[1]; 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 583d85ec04..e3956a8544 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 @@ -103,12 +103,12 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 algebraic_variables[1] = constants[2]*(states[0]-computed_constants[0]) algebraic_variables[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computed_constants[2]) external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) algebraic_variables[3] = constants[3]*pow(external_variables[0], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic_variables[0]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1])/constants[0] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[3]-algebraic_variables[2]-algebraic_variables[1])/constants[0] algebraic_variables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) algebraic_variables[6] = 0.07*exp(states[0]/20.0) rates[1] = algebraic_variables[6]*(1.0-states[1])-algebraic_variables[7]*states[1] 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 b574661888..57063c936a 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 @@ -110,11 +110,11 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; double leakage_current_i_L = constants[2]*(states[0]-computedConstants[0]); double potassium_channel_i_K = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); double sodium_channel_i_Na = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-membrane_i_Stim+sodium_channel_i_Na+potassium_channel_i_K+leakage_current_i_L)/constants[0]; + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (membrane_i_Stim-sodium_channel_i_Na-potassium_channel_i_K-leakage_current_i_L)/constants[0]; double sodium_channel_m_gate_beta_m = 4.0*exp(states[0]/18.0); double sodium_channel_m_gate_alpha_m = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = sodium_channel_m_gate_alpha_m*(1.0-states[2])-sodium_channel_m_gate_beta_m*states[2]; 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 7783e0c810..e1c74612cc 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 @@ -86,11 +86,11 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 leakage_current_i_L = constants[2]*(states[0]-computed_constants[0]) potassium_channel_i_K = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) sodium_channel_i_Na = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-membrane_i_Stim+sodium_channel_i_Na+potassium_channel_i_K+leakage_current_i_L)/constants[0] + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (membrane_i_Stim-sodium_channel_i_Na-potassium_channel_i_K-leakage_current_i_L)/constants[0] sodium_channel_m_gate_beta_m = 4.0*exp(states[0]/18.0) sodium_channel_m_gate_alpha_m = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = sodium_channel_m_gate_alpha_m*(1.0-states[2])-sodium_channel_m_gate_beta_m*states[2] 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 7447b68dd9..c3b8581260 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 @@ -127,12 +127,12 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; double leakage_current_i_L = constants[2]*(states[0]-computedConstants[0]); double potassium_channel_i_K = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraicVariables[0] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - rates[0] = -(-membrane_i_Stim+externalVariables[0]+potassium_channel_i_K+leakage_current_i_L)/constants[0]; + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (membrane_i_Stim-externalVariables[0]-potassium_channel_i_K-leakage_current_i_L)/constants[0]; double sodium_channel_m_gate_beta_m = 4.0*exp(states[0]/18.0); rates[2] = algebraicVariables[0]*(1.0-states[2])-sodium_channel_m_gate_beta_m*states[2]; double sodium_channel_h_gate_beta_h = 1.0/(exp((states[0]+30.0)/10.0)+1.0); 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 27ed0fe9ed..d681565b35 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 @@ -96,12 +96,12 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 leakage_current_i_L = constants[2]*(states[0]-computed_constants[0]) potassium_channel_i_K = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic_variables[0] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - rates[0] = -(-membrane_i_Stim+external_variables[0]+potassium_channel_i_K+leakage_current_i_L)/constants[0] + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (membrane_i_Stim-external_variables[0]-potassium_channel_i_K-leakage_current_i_L)/constants[0] sodium_channel_m_gate_beta_m = 4.0*exp(states[0]/18.0) rates[2] = algebraic_variables[0]*(1.0-states[2])-sodium_channel_m_gate_beta_m*states[2] sodium_channel_h_gate_beta_h = 1.0/(exp((states[0]+30.0)/10.0)+1.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 10f5228393..0256fa9ab3 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 @@ -114,14 +114,14 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; double leakage_current_E_L = constants[1]-10.613; algebraicVariables[1] = constants[2]*(states[0]-leakage_current_E_L); double potassium_channel_E_K = constants[1]+12.0; algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-potassium_channel_E_K); double sodium_channel_E_Na = constants[1]-115.0; algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-sodium_channel_E_Na); - rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[3]-algebraicVariables[2]-algebraicVariables[1])/constants[0]; algebraicVariables[5] = 4.0*exp(states[0]/18.0); algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2]; 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 8dabe6cfb4..91231ae275 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 @@ -91,14 +91,14 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 leakage_current_E_L = constants[1]-10.613 algebraic_variables[1] = constants[2]*(states[0]-leakage_current_E_L) potassium_channel_E_K = constants[1]+12.0 algebraic_variables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-potassium_channel_E_K) sodium_channel_E_Na = constants[1]-115.0 algebraic_variables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-sodium_channel_E_Na) - rates[0] = -(-algebraic_variables[0]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1])/constants[0] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[3]-algebraic_variables[2]-algebraic_variables[1])/constants[0] algebraic_variables[5] = 4.0*exp(states[0]/18.0) algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic_variables[4]*(1.0-states[2])-algebraic_variables[5]*states[2] 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 dac3552991..86bbdee141 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 @@ -131,13 +131,13 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; double leakage_current_E_L = constants[1]-10.613; algebraicVariables[1] = constants[2]*(states[0]-leakage_current_E_L); algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[0]); algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - rates[0] = -(-algebraicVariables[0]+externalVariables[0]+algebraicVariables[2]+algebraicVariables[1])/constants[0]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-externalVariables[0]-algebraicVariables[2]-algebraicVariables[1])/constants[0]; algebraicVariables[4] = 4.0*exp(states[0]/18.0); rates[2] = algebraicVariables[3]*(1.0-states[2])-algebraicVariables[4]*states[2]; algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); 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 b45b7e7666..4bad67b842 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 @@ -100,13 +100,13 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 leakage_current_E_L = constants[1]-10.613 algebraic_variables[1] = constants[2]*(states[0]-leakage_current_E_L) algebraic_variables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[0]) algebraic_variables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - rates[0] = -(-algebraic_variables[0]+external_variables[0]+algebraic_variables[2]+algebraic_variables[1])/constants[0] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-external_variables[0]-algebraic_variables[2]-algebraic_variables[1])/constants[0] algebraic_variables[4] = 4.0*exp(states[0]/18.0) rates[2] = algebraic_variables[3]*(1.0-states[2])-algebraic_variables[4]*states[2] algebraic_variables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.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 d66a70c0e5..76aa82a61e 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 @@ -112,14 +112,14 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { double membrane_Cm = 1.0; - algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; double leakage_current_g_L = 0.3; algebraicVariables[1] = leakage_current_g_L*(states[0]-computedConstants[0]); double potassium_channel_g_K = 36.0; algebraicVariables[2] = potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computedConstants[2]); double sodium_channel_g_Na = 120.0; algebraicVariables[3] = sodium_channel_g_Na*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/membrane_Cm; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[3]-algebraicVariables[2]-algebraicVariables[1])/membrane_Cm; algebraicVariables[5] = 4.0*exp(states[0]/18.0); algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2]; 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 e24a3e2898..d580860b77 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 @@ -88,14 +88,14 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): membrane_Cm = 1.0 - algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 leakage_current_g_L = 0.3 algebraic_variables[1] = leakage_current_g_L*(states[0]-computed_constants[0]) potassium_channel_g_K = 36.0 algebraic_variables[2] = potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computed_constants[2]) sodium_channel_g_Na = 120.0 algebraic_variables[3] = sodium_channel_g_Na*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic_variables[0]+algebraic_variables[3]+algebraic_variables[2]+algebraic_variables[1])/membrane_Cm + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[3]-algebraic_variables[2]-algebraic_variables[1])/membrane_Cm algebraic_variables[5] = 4.0*exp(states[0]/18.0) algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic_variables[4]*(1.0-states[2])-algebraic_variables[5]*states[2] 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 2eb83833a1..728129e548 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 @@ -128,14 +128,14 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; double leakage_current_g_L = 0.3; algebraicVariables[1] = leakage_current_g_L*(states[0]-computedConstants[0]); double potassium_channel_g_K = 36.0; algebraicVariables[2] = potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - rates[0] = -(-algebraicVariables[0]+externalVariables[0]+algebraicVariables[2]+algebraicVariables[1])/constants[0]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-externalVariables[0]-algebraicVariables[2]-algebraicVariables[1])/constants[0]; algebraicVariables[4] = 4.0*exp(states[0]/18.0); rates[2] = algebraicVariables[3]*(1.0-states[2])-algebraicVariables[4]*states[2]; algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); 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 0102d6d4fb..095f52c8fd 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 @@ -97,14 +97,14 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 leakage_current_g_L = 0.3 algebraic_variables[1] = leakage_current_g_L*(states[0]-computed_constants[0]) potassium_channel_g_K = 36.0 algebraic_variables[2] = potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic_variables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - rates[0] = -(-algebraic_variables[0]+external_variables[0]+algebraic_variables[2]+algebraic_variables[1])/constants[0] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-external_variables[0]-algebraic_variables[2]-algebraic_variables[1])/constants[0] algebraic_variables[4] = 4.0*exp(states[0]/18.0) rates[2] = algebraic_variables[3]*(1.0-states[2])-algebraic_variables[4]*states[2] algebraic_variables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.c new file mode 100644 index 0000000000..58ca96e2ed --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.c @@ -0,0 +1,150 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.untracked.control.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + 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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[1]-10.613; + computedConstants[1] = constants[1]-115.0; + computedConstants[2] = constants[1]+12.0; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[1] = constants[2]*(states[0]-computedConstants[0]); + algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[3]-algebraicVariables[2]-algebraicVariables[1])/constants[0]; + algebraicVariables[5] = 4.0*exp(states[0]/18.0); + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2]; + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[6] = 0.07*exp(states[0]/20.0); + rates[1] = algebraicVariables[6]*(1.0-states[1])-algebraicVariables[7]*states[1]; + algebraicVariables[9] = 0.125*exp(states[0]/80.0); + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + rates[3] = algebraicVariables[8]*(1.0-states[3])-algebraicVariables[9]*states[3]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[1] = constants[2]*(states[0]-computedConstants[0]); + algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraicVariables[5] = 4.0*exp(states[0]/18.0); + algebraicVariables[6] = 0.07*exp(states[0]/20.0); + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraicVariables[9] = 0.125*exp(states[0]/80.0); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.h similarity index 100% rename from tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.h rename to tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.h diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.py new file mode 100644 index 0000000000..5bf857bc9d --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.py @@ -0,0 +1,124 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 10 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = constants[1]-10.613 + computed_constants[1] = constants[1]-115.0 + computed_constants[2] = constants[1]+12.0 + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[1] = constants[2]*(states[0]-computed_constants[0]) + algebraic_variables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic_variables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[3]-algebraic_variables[2]-algebraic_variables[1])/constants[0] + algebraic_variables[5] = 4.0*exp(states[0]/18.0) + algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + rates[2] = algebraic_variables[4]*(1.0-states[2])-algebraic_variables[5]*states[2] + algebraic_variables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic_variables[6] = 0.07*exp(states[0]/20.0) + rates[1] = algebraic_variables[6]*(1.0-states[1])-algebraic_variables[7]*states[1] + algebraic_variables[9] = 0.125*exp(states[0]/80.0) + algebraic_variables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + rates[3] = algebraic_variables[8]*(1.0-states[3])-algebraic_variables[9]*states[3] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[1] = constants[2]*(states[0]-computed_constants[0]) + algebraic_variables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic_variables[5] = 4.0*exp(states[0]/18.0) + algebraic_variables[6] = 0.07*exp(states[0]/20.0) + algebraic_variables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic_variables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic_variables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic_variables[9] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.with.externals.c new file mode 100644 index 0000000000..431d16da52 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.with.externals.c @@ -0,0 +1,165 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.untracked.control.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 9; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = constants[1]-10.613; + computedConstants[1] = constants[1]-115.0; + computedConstants[2] = constants[1]+12.0; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[1] = constants[2]*(states[0]-computedConstants[0]); + algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-externalVariables[0]-algebraicVariables[2]-algebraicVariables[1])/constants[0]; + algebraicVariables[4] = 4.0*exp(states[0]/18.0); + rates[2] = algebraicVariables[3]*(1.0-states[2])-algebraicVariables[4]*states[2]; + algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[5] = 0.07*exp(states[0]/20.0); + rates[1] = algebraicVariables[5]*(1.0-states[1])-algebraicVariables[6]*states[1]; + algebraicVariables[8] = 0.125*exp(states[0]/80.0); + algebraicVariables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + rates[3] = algebraicVariables[7]*(1.0-states[3])-algebraicVariables[8]*states[3]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[1] = constants[2]*(states[0]-computedConstants[0]); + algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[4] = 4.0*exp(states[0]/18.0); + algebraicVariables[5] = 0.07*exp(states[0]/20.0); + algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraicVariables[8] = 0.125*exp(states[0]/80.0); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.with.externals.h similarity index 100% rename from tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h rename to tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.with.externals.h diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.with.externals.py new file mode 100644 index 0000000000..d986d2b716 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.control.with.externals.py @@ -0,0 +1,132 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 9 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = constants[1]-10.613 + computed_constants[1] = constants[1]-115.0 + computed_constants[2] = constants[1]+12.0 + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[1] = constants[2]*(states[0]-computed_constants[0]) + algebraic_variables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic_variables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-external_variables[0]-algebraic_variables[2]-algebraic_variables[1])/constants[0] + algebraic_variables[4] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic_variables[3]*(1.0-states[2])-algebraic_variables[4]*states[2] + algebraic_variables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic_variables[5] = 0.07*exp(states[0]/20.0) + rates[1] = algebraic_variables[5]*(1.0-states[1])-algebraic_variables[6]*states[1] + algebraic_variables[8] = 0.125*exp(states[0]/80.0) + algebraic_variables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + rates[3] = algebraic_variables[7]*(1.0-states[3])-algebraic_variables[8]*states[3] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[1] = constants[2]*(states[0]-computed_constants[0]) + algebraic_variables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[4] = 4.0*exp(states[0]/18.0) + algebraic_variables[5] = 0.07*exp(states[0]/20.0) + algebraic_variables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic_variables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic_variables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic_variables[8] = 0.125*exp(states[0]/80.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 797b5008cb..52a8b93cfd 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 @@ -95,7 +95,6 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { double membrane_Cm = 1.0; - double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; double leakage_current_g_L = 0.3; double membrane_E_R = 0.0; double leakage_current_E_L = membrane_E_R-10.613; @@ -106,7 +105,8 @@ void computeRates(double voi, double *states, double *rates, double *constants, double sodium_channel_g_Na = 120.0; double sodium_channel_E_Na = membrane_E_R-115.0; double sodium_channel_i_Na = sodium_channel_g_Na*pow(states[2], 3.0)*states[1]*(states[0]-sodium_channel_E_Na); - rates[0] = -(-membrane_i_Stim+sodium_channel_i_Na+potassium_channel_i_K+leakage_current_i_L)/membrane_Cm; + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (membrane_i_Stim-sodium_channel_i_Na-potassium_channel_i_K-leakage_current_i_L)/membrane_Cm; double sodium_channel_m_gate_beta_m = 4.0*exp(states[0]/18.0); double sodium_channel_m_gate_alpha_m = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = sodium_channel_m_gate_alpha_m*(1.0-states[2])-sodium_channel_m_gate_beta_m*states[2]; 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 a3227e235c..bff773f279 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 @@ -72,7 +72,6 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): membrane_Cm = 1.0 - membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 leakage_current_g_L = 0.3 membrane_E_R = 0.0 leakage_current_E_L = membrane_E_R-10.613 @@ -83,7 +82,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v sodium_channel_g_Na = 120.0 sodium_channel_E_Na = membrane_E_R-115.0 sodium_channel_i_Na = sodium_channel_g_Na*pow(states[2], 3.0)*states[1]*(states[0]-sodium_channel_E_Na) - rates[0] = -(-membrane_i_Stim+sodium_channel_i_Na+potassium_channel_i_K+leakage_current_i_L)/membrane_Cm + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (membrane_i_Stim-sodium_channel_i_Na-potassium_channel_i_K-leakage_current_i_L)/membrane_Cm sodium_channel_m_gate_beta_m = 4.0*exp(states[0]/18.0) sodium_channel_m_gate_alpha_m = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = sodium_channel_m_gate_alpha_m*(1.0-states[2])-sodium_channel_m_gate_beta_m*states[2] 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 35a80d5e2b..72a96da1b3 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 @@ -116,7 +116,6 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; double leakage_current_g_L = 0.3; double membrane_E_R = 0.0; double leakage_current_E_L = membrane_E_R-10.613; @@ -125,7 +124,8 @@ void computeRates(double voi, double *states, double *rates, double *constants, double potassium_channel_i_K = potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computedConstants[0]); algebraicVariables[0] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - rates[0] = -(-membrane_i_Stim+externalVariables[0]+potassium_channel_i_K+leakage_current_i_L)/constants[0]; + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (membrane_i_Stim-externalVariables[0]-potassium_channel_i_K-leakage_current_i_L)/constants[0]; double sodium_channel_m_gate_beta_m = 4.0*exp(states[0]/18.0); rates[2] = algebraicVariables[0]*(1.0-states[2])-sodium_channel_m_gate_beta_m*states[2]; double sodium_channel_h_gate_beta_h = 1.0/(exp((states[0]+30.0)/10.0)+1.0); 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 c047cd4fac..06f6cd11a5 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 @@ -85,7 +85,6 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 leakage_current_g_L = 0.3 membrane_E_R = 0.0 leakage_current_E_L = membrane_E_R-10.613 @@ -94,7 +93,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v potassium_channel_i_K = potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computed_constants[0]) algebraic_variables[0] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - rates[0] = -(-membrane_i_Stim+external_variables[0]+potassium_channel_i_K+leakage_current_i_L)/constants[0] + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (membrane_i_Stim-external_variables[0]-potassium_channel_i_K-leakage_current_i_L)/constants[0] sodium_channel_m_gate_beta_m = 4.0*exp(states[0]/18.0) rates[2] = algebraic_variables[0]*(1.0-states[2])-sodium_channel_m_gate_beta_m*states[2] sodium_channel_h_gate_beta_h = 1.0/(exp((states[0]+30.0)/10.0)+1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.cellml b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.cellml similarity index 100% rename from tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.cellml rename to tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.cellml 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.variant.external.h similarity index 100% rename from tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.h rename to tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external.h diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_linux.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_linux.c new file mode 100644 index 0000000000..2ccc13a40b --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_linux.c @@ -0,0 +1,157 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.external.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 3; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 8; +const size_t EXTERNAL_VARIABLE_COUNT = 3; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"V", "millivolt", "membrane"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * 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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.6; + states[1] = 0.05; + states[2] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + algebraicVariables[3] = 0.1*externalVariables[1]/(-1.0+exp(2.5+0.1*externalVariables[1]))+2.5/(-1.0+exp(2.5+0.1*externalVariables[1])); + algebraicVariables[4] = 4.0*exp(0.0555555555555556*externalVariables[1]); + rates[1] = -states[1]*algebraicVariables[4]+(1.0-states[1])*algebraicVariables[3]; + algebraicVariables[5] = 0.07*exp(0.05*externalVariables[1]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*externalVariables[1])); + rates[0] = -states[0]*algebraicVariables[6]+(1.0-states[0])*algebraicVariables[5]; + externalVariables[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 2); + algebraicVariables[7] = 0.125*exp(0.0125*externalVariables[1]); + rates[2] = -states[2]*algebraicVariables[7]+(1.0-states[2])*externalVariables[2]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + algebraicVariables[1] = externalVariables[1]*constants[2]-computedConstants[0]*constants[2]; + externalVariables[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 2); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[2] = -pow(states[2], 4.0)*computedConstants[2]*constants[4]+externalVariables[1]*pow(states[2], 4.0)*constants[4]; +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_linux.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_linux.py new file mode 100644 index 0000000000..6448e3dc2d --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_linux.py @@ -0,0 +1,124 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 3 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 8 +EXTERNAL_VARIABLE_COUNT = 3 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.6 + states[1] = 0.05 + states[2] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + algebraic_variables[3] = 0.1*external_variables[1]/(-1.0+exp(2.5+0.1*external_variables[1]))+2.5/(-1.0+exp(2.5+0.1*external_variables[1])) + algebraic_variables[4] = 4.0*exp(0.0555555555555556*external_variables[1]) + rates[1] = -states[1]*algebraic_variables[4]+(1.0-states[1])*algebraic_variables[3] + algebraic_variables[5] = 0.07*exp(0.05*external_variables[1]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*external_variables[1])) + rates[0] = -states[0]*algebraic_variables[6]+(1.0-states[0])*algebraic_variables[5] + external_variables[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 2) + algebraic_variables[7] = 0.125*exp(0.0125*external_variables[1]) + rates[2] = -states[2]*algebraic_variables[7]+(1.0-states[2])*external_variables[2] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + algebraic_variables[1] = external_variables[1]*constants[2]-computed_constants[0]*constants[2] + external_variables[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 2) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[2] = -pow(states[2], 4.0)*computed_constants[2]*constants[4]+external_variables[1]*pow(states[2], 4.0)*constants[4] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_macos.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_macos.c new file mode 100644 index 0000000000..2ccc13a40b --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_macos.c @@ -0,0 +1,157 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.external.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 3; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 8; +const size_t EXTERNAL_VARIABLE_COUNT = 3; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"V", "millivolt", "membrane"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * 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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.6; + states[1] = 0.05; + states[2] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + algebraicVariables[3] = 0.1*externalVariables[1]/(-1.0+exp(2.5+0.1*externalVariables[1]))+2.5/(-1.0+exp(2.5+0.1*externalVariables[1])); + algebraicVariables[4] = 4.0*exp(0.0555555555555556*externalVariables[1]); + rates[1] = -states[1]*algebraicVariables[4]+(1.0-states[1])*algebraicVariables[3]; + algebraicVariables[5] = 0.07*exp(0.05*externalVariables[1]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*externalVariables[1])); + rates[0] = -states[0]*algebraicVariables[6]+(1.0-states[0])*algebraicVariables[5]; + externalVariables[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 2); + algebraicVariables[7] = 0.125*exp(0.0125*externalVariables[1]); + rates[2] = -states[2]*algebraicVariables[7]+(1.0-states[2])*externalVariables[2]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + algebraicVariables[1] = externalVariables[1]*constants[2]-computedConstants[0]*constants[2]; + externalVariables[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 2); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[2] = -pow(states[2], 4.0)*computedConstants[2]*constants[4]+externalVariables[1]*pow(states[2], 4.0)*constants[4]; +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_macos.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_macos.py new file mode 100644 index 0000000000..6448e3dc2d --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_macos.py @@ -0,0 +1,124 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 3 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 8 +EXTERNAL_VARIABLE_COUNT = 3 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.6 + states[1] = 0.05 + states[2] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + algebraic_variables[3] = 0.1*external_variables[1]/(-1.0+exp(2.5+0.1*external_variables[1]))+2.5/(-1.0+exp(2.5+0.1*external_variables[1])) + algebraic_variables[4] = 4.0*exp(0.0555555555555556*external_variables[1]) + rates[1] = -states[1]*algebraic_variables[4]+(1.0-states[1])*algebraic_variables[3] + algebraic_variables[5] = 0.07*exp(0.05*external_variables[1]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*external_variables[1])) + rates[0] = -states[0]*algebraic_variables[6]+(1.0-states[0])*algebraic_variables[5] + external_variables[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 2) + algebraic_variables[7] = 0.125*exp(0.0125*external_variables[1]) + rates[2] = -states[2]*algebraic_variables[7]+(1.0-states[2])*external_variables[2] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + algebraic_variables[1] = external_variables[1]*constants[2]-computed_constants[0]*constants[2] + external_variables[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 2) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[2] = -pow(states[2], 4.0)*computed_constants[2]*constants[4]+external_variables[1]*pow(states[2], 4.0)*constants[4] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_windows.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_windows.c new file mode 100644 index 0000000000..de37e59850 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_windows.c @@ -0,0 +1,157 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.external.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 3; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 8; +const size_t EXTERNAL_VARIABLE_COUNT = 3; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"V", "millivolt", "membrane"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * 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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.6; + states[1] = 0.05; + states[2] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + algebraicVariables[4] = 4.0*exp(0.0555555555555556*externalVariables[1]); + algebraicVariables[3] = 0.1*externalVariables[1]/(-1.0+exp(2.5+0.1*externalVariables[1]))+2.5/(-1.0+exp(2.5+0.1*externalVariables[1])); + rates[1] = (1.0-states[1])*algebraicVariables[3]-states[1]*algebraicVariables[4]; + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*externalVariables[1])); + algebraicVariables[5] = 0.07*exp(0.05*externalVariables[1]); + rates[0] = (1.0-states[0])*algebraicVariables[5]-states[0]*algebraicVariables[6]; + algebraicVariables[7] = 0.125*exp(0.0125*externalVariables[1]); + externalVariables[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 2); + rates[2] = (1.0-states[2])*externalVariables[2]-states[2]*algebraicVariables[7]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + algebraicVariables[1] = externalVariables[1]*constants[2]-computedConstants[0]*constants[2]; + externalVariables[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 2); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[2] = -pow(states[2], 4.0)*computedConstants[2]*constants[4]+externalVariables[1]*pow(states[2], 4.0)*constants[4]; +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_windows.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_windows.py new file mode 100644 index 0000000000..2f000fb6a9 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.external_windows.py @@ -0,0 +1,124 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 3 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 8 +EXTERNAL_VARIABLE_COUNT = 3 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.6 + states[1] = 0.05 + states[2] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + algebraic_variables[4] = 4.0*exp(0.0555555555555556*external_variables[1]) + algebraic_variables[3] = 0.1*external_variables[1]/(-1.0+exp(2.5+0.1*external_variables[1]))+2.5/(-1.0+exp(2.5+0.1*external_variables[1])) + rates[1] = (1.0-states[1])*algebraic_variables[3]-states[1]*algebraic_variables[4] + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*external_variables[1])) + algebraic_variables[5] = 0.07*exp(0.05*external_variables[1]) + rates[0] = (1.0-states[0])*algebraic_variables[5]-states[0]*algebraic_variables[6] + algebraic_variables[7] = 0.125*exp(0.0125*external_variables[1]) + external_variables[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 2) + rates[2] = (1.0-states[2])*external_variables[2]-states[2]*algebraic_variables[7] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + algebraic_variables[1] = external_variables[1]*constants[2]-computed_constants[0]*constants[2] + external_variables[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 2) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[2] = -pow(states[2], 4.0)*computed_constants[2]*constants[4]+external_variables[1]*pow(states[2], 4.0)*constants[4] 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.variant.h similarity index 100% rename from tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.h rename to tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.h 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.variant.untracked.algebraic.variables.h similarity index 97% rename from tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h rename to tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.h index 734b4d9386..49a0beeaa7 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.variant.untracked.algebraic.variables.h @@ -13,8 +13,8 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { - char name[8]; - char units[16]; + char name[5]; + char units[15]; char component[25]; } VariableInfo; 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.variant.untracked.algebraic.variables.with.externals.h similarity index 100% rename from tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.h rename to tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals.h diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_linux.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_linux.c new file mode 100644 index 0000000000..15ffe8892b --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_linux.c @@ -0,0 +1,150 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.algebraic.variables.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + double potassium_channel_i_K = -pow(states[3], 4.0)*constants[4]*computedConstants[2]+states[0]*pow(states[3], 4.0)*constants[4]; + double leakage_current_i_L = states[0]*constants[2]-constants[2]*computedConstants[0]; + algebraicVariables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (membrane_i_Stim-externalVariables[0]-leakage_current_i_L-potassium_channel_i_K)/constants[0]; + double sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*algebraicVariables[0]; + double sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]); + double sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h; + double potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + double potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_linux.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_linux.py new file mode 100644 index 0000000000..0c0cc9102f --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_linux.py @@ -0,0 +1,117 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 1 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + potassium_channel_i_K = -pow(states[3], 4.0)*constants[4]*computed_constants[2]+states[0]*pow(states[3], 4.0)*constants[4] + leakage_current_i_L = states[0]*constants[2]-constants[2]*computed_constants[0] + algebraic_variables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (membrane_i_Stim-external_variables[0]-leakage_current_i_L-potassium_channel_i_K)/constants[0] + sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*algebraic_variables[0] + sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]) + sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h + potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_macos.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_macos.c new file mode 100644 index 0000000000..e5528df98b --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_macos.c @@ -0,0 +1,150 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.algebraic.variables.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + double potassium_channel_i_K = -pow(states[3], 4.0)*constants[4]*computedConstants[2]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + double leakage_current_i_L = states[0]*constants[2]-constants[2]*computedConstants[0]; + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (membrane_i_Stim-leakage_current_i_L-externalVariables[0]-potassium_channel_i_K)/constants[0]; + double sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*algebraicVariables[0]; + double sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]); + double sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h; + double potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + double potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_macos.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_macos.py new file mode 100644 index 0000000000..802979dd2d --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_macos.py @@ -0,0 +1,117 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 1 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + potassium_channel_i_K = -pow(states[3], 4.0)*constants[4]*computed_constants[2]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + leakage_current_i_L = states[0]*constants[2]-constants[2]*computed_constants[0] + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (membrane_i_Stim-leakage_current_i_L-external_variables[0]-potassium_channel_i_K)/constants[0] + sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*algebraic_variables[0] + sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]) + sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h + potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_windows.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_windows.c new file mode 100644 index 0000000000..7971ec7682 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_windows.c @@ -0,0 +1,150 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.algebraic.variables.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraicVariables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + double leakage_current_i_L = states[0]*constants[2]-constants[2]*computedConstants[0]; + double potassium_channel_i_K = states[0]*pow(states[3], 4.0)*constants[4]-pow(states[3], 4.0)*constants[4]*computedConstants[2]; + rates[0] = (-potassium_channel_i_K-leakage_current_i_L-externalVariables[0]+membrane_i_Stim)/constants[0]; + double sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = (1.0-states[2])*algebraicVariables[0]-states[2]*sodium_channel_m_gate_beta_m; + double sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])); + double sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]); + rates[1] = (1.0-states[1])*sodium_channel_h_gate_alpha_h-states[1]*sodium_channel_h_gate_beta_h; + double potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]); + double potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + rates[3] = (1.0-states[3])*potassium_channel_n_gate_alpha_n-states[3]*potassium_channel_n_gate_beta_n; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_windows.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_windows.py new file mode 100644 index 0000000000..3b25e43290 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables.with.externals_windows.py @@ -0,0 +1,117 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 1 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic_variables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + leakage_current_i_L = states[0]*constants[2]-constants[2]*computed_constants[0] + potassium_channel_i_K = states[0]*pow(states[3], 4.0)*constants[4]-pow(states[3], 4.0)*constants[4]*computed_constants[2] + rates[0] = (-potassium_channel_i_K-leakage_current_i_L-external_variables[0]+membrane_i_Stim)/constants[0] + sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = (1.0-states[2])*algebraic_variables[0]-states[2]*sodium_channel_m_gate_beta_m + sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])) + sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]) + rates[1] = (1.0-states[1])*sodium_channel_h_gate_alpha_h-states[1]*sodium_channel_h_gate_beta_h + potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]) + potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + rates[3] = (1.0-states[3])*potassium_channel_n_gate_alpha_n-states[3]*potassium_channel_n_gate_beta_n + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_linux.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_linux.c new file mode 100644 index 0000000000..539e73bf5e --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_linux.c @@ -0,0 +1,131 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.algebraic.variables.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double potassium_channel_i_K = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + double leakage_current_i_L = states[0]*constants[2]-computedConstants[0]*constants[2]; + double sodium_channel_i_Na = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]; + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (membrane_i_Stim-sodium_channel_i_Na-leakage_current_i_L-potassium_channel_i_K)/constants[0]; + double sodium_channel_m_gate_alpha_m = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + double sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*sodium_channel_m_gate_alpha_m; + double sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]); + double sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h; + double potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + double potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n; +} + +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.variant.untracked.algebraic.variables_linux.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_linux.py new file mode 100644 index 0000000000..5b9db25880 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_linux.py @@ -0,0 +1,106 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 0 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + potassium_channel_i_K = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + leakage_current_i_L = states[0]*constants[2]-computed_constants[0]*constants[2] + sodium_channel_i_Na = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1] + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (membrane_i_Stim-sodium_channel_i_Na-leakage_current_i_L-potassium_channel_i_K)/constants[0] + sodium_channel_m_gate_alpha_m = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*sodium_channel_m_gate_alpha_m + sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]) + sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h + potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_macos.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_macos.c new file mode 100644 index 0000000000..5ef44ebc87 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_macos.c @@ -0,0 +1,131 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.algebraic.variables.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double sodium_channel_i_Na = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]; + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + double leakage_current_i_L = states[0]*constants[2]-computedConstants[0]*constants[2]; + double potassium_channel_i_K = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + rates[0] = (-potassium_channel_i_K-leakage_current_i_L+membrane_i_Stim-sodium_channel_i_Na)/constants[0]; + double sodium_channel_m_gate_alpha_m = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + double sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*sodium_channel_m_gate_alpha_m; + double sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]); + double sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h; + double potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + double potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n; +} + +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.variant.untracked.algebraic.variables_macos.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_macos.py new file mode 100644 index 0000000000..926919edbd --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_macos.py @@ -0,0 +1,106 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 0 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + sodium_channel_i_Na = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1] + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + leakage_current_i_L = states[0]*constants[2]-computed_constants[0]*constants[2] + potassium_channel_i_K = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + rates[0] = (-potassium_channel_i_K-leakage_current_i_L+membrane_i_Stim-sodium_channel_i_Na)/constants[0] + sodium_channel_m_gate_alpha_m = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*sodium_channel_m_gate_alpha_m + sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]) + sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h + potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_windows.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_windows.c new file mode 100644 index 0000000000..dede8f63b0 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_windows.c @@ -0,0 +1,131 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.algebraic.variables.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + double leakage_current_i_L = states[0]*constants[2]-computedConstants[0]*constants[2]; + double potassium_channel_i_K = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + double sodium_channel_i_Na = -states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]+states[0]*states[1]*pow(states[2], 3.0)*constants[3]; + rates[0] = (-sodium_channel_i_Na-potassium_channel_i_K-leakage_current_i_L+membrane_i_Stim)/constants[0]; + double sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]); + double sodium_channel_m_gate_alpha_m = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + rates[2] = (1.0-states[2])*sodium_channel_m_gate_alpha_m-states[2]*sodium_channel_m_gate_beta_m; + double sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])); + double sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]); + rates[1] = (1.0-states[1])*sodium_channel_h_gate_alpha_h-states[1]*sodium_channel_h_gate_beta_h; + double potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]); + double potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + rates[3] = (1.0-states[3])*potassium_channel_n_gate_alpha_n-states[3]*potassium_channel_n_gate_beta_n; +} + +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.variant.untracked.algebraic.variables_windows.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_windows.py new file mode 100644 index 0000000000..c0f8fd03cf --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.algebraic.variables_windows.py @@ -0,0 +1,106 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 0 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + leakage_current_i_L = states[0]*constants[2]-computed_constants[0]*constants[2] + potassium_channel_i_K = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + sodium_channel_i_Na = -states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1]+states[0]*states[1]*pow(states[2], 3.0)*constants[3] + rates[0] = (-sodium_channel_i_Na-potassium_channel_i_K-leakage_current_i_L+membrane_i_Stim)/constants[0] + sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]) + sodium_channel_m_gate_alpha_m = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + rates[2] = (1.0-states[2])*sodium_channel_m_gate_alpha_m-states[2]*sodium_channel_m_gate_beta_m + sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])) + sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]) + rates[1] = (1.0-states[1])*sodium_channel_h_gate_alpha_h-states[1]*sodium_channel_h_gate_beta_h + potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]) + potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + rates[3] = (1.0-states[3])*potassium_channel_n_gate_alpha_n-states[3]*potassium_channel_n_gate_beta_n + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass 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.variant.untracked.computed.constants.h similarity index 100% rename from tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.h rename to tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.h 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.variant.untracked.computed.constants.with.externals.h similarity index 100% rename from tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.h rename to tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals.h diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_linux.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_linux.c new file mode 100644 index 0000000000..3aa49ffc4b --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_linux.c @@ -0,0 +1,163 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.computed.constants.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 9; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[2] = -pow(states[3], 4.0)*constants[4]*computedConstants[0]+states[0]*pow(states[3], 4.0)*constants[4]; + double leakage_current_E_L = -10.613+constants[1]; + algebraicVariables[1] = states[0]*constants[2]-constants[2]*leakage_current_E_L; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-externalVariables[0]-algebraicVariables[1]-algebraicVariables[2])/constants[0]; + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*algebraicVariables[4]+(1.0-states[2])*algebraicVariables[3]; + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*algebraicVariables[6]+(1.0-states[1])*algebraicVariables[5]; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*algebraicVariables[8]+(1.0-states[3])*algebraicVariables[7]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + double leakage_current_E_L = -10.613+constants[1]; + algebraicVariables[1] = states[0]*constants[2]-constants[2]*leakage_current_E_L; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[2] = -pow(states[3], 4.0)*constants[4]*computedConstants[0]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_linux.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_linux.py new file mode 100644 index 0000000000..486d4dcd82 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_linux.py @@ -0,0 +1,130 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 9 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[2] = -pow(states[3], 4.0)*constants[4]*computed_constants[0]+states[0]*pow(states[3], 4.0)*constants[4] + leakage_current_E_L = -10.613+constants[1] + algebraic_variables[1] = states[0]*constants[2]-constants[2]*leakage_current_E_L + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-external_variables[0]-algebraic_variables[1]-algebraic_variables[2])/constants[0] + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*algebraic_variables[4]+(1.0-states[2])*algebraic_variables[3] + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*algebraic_variables[6]+(1.0-states[1])*algebraic_variables[5] + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*algebraic_variables[8]+(1.0-states[3])*algebraic_variables[7] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + leakage_current_E_L = -10.613+constants[1] + algebraic_variables[1] = states[0]*constants[2]-constants[2]*leakage_current_E_L + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[2] = -pow(states[3], 4.0)*constants[4]*computed_constants[0]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_macos.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_macos.c new file mode 100644 index 0000000000..9d52512741 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_macos.c @@ -0,0 +1,163 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.computed.constants.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 9; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[2] = -pow(states[3], 4.0)*constants[4]*computedConstants[0]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + double leakage_current_E_L = -10.613+constants[1]; + algebraicVariables[1] = states[0]*constants[2]-constants[2]*leakage_current_E_L; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[1]-externalVariables[0]-algebraicVariables[2])/constants[0]; + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*algebraicVariables[4]+(1.0-states[2])*algebraicVariables[3]; + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*algebraicVariables[6]+(1.0-states[1])*algebraicVariables[5]; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*algebraicVariables[8]+(1.0-states[3])*algebraicVariables[7]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + double leakage_current_E_L = -10.613+constants[1]; + algebraicVariables[1] = states[0]*constants[2]-constants[2]*leakage_current_E_L; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[2] = -pow(states[3], 4.0)*constants[4]*computedConstants[0]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_macos.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_macos.py new file mode 100644 index 0000000000..8a4647e269 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_macos.py @@ -0,0 +1,130 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 9 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[2] = -pow(states[3], 4.0)*constants[4]*computed_constants[0]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + leakage_current_E_L = -10.613+constants[1] + algebraic_variables[1] = states[0]*constants[2]-constants[2]*leakage_current_E_L + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[1]-external_variables[0]-algebraic_variables[2])/constants[0] + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*algebraic_variables[4]+(1.0-states[2])*algebraic_variables[3] + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*algebraic_variables[6]+(1.0-states[1])*algebraic_variables[5] + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*algebraic_variables[8]+(1.0-states[3])*algebraic_variables[7] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + leakage_current_E_L = -10.613+constants[1] + algebraic_variables[1] = states[0]*constants[2]-constants[2]*leakage_current_E_L + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[2] = -pow(states[3], 4.0)*constants[4]*computed_constants[0]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_windows.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_windows.c new file mode 100644 index 0000000000..bc2fc16faa --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_windows.c @@ -0,0 +1,163 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.computed.constants.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 9; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + double leakage_current_E_L = -10.613+constants[1]; + algebraicVariables[1] = states[0]*constants[2]-constants[2]*leakage_current_E_L; + algebraicVariables[2] = states[0]*pow(states[3], 4.0)*constants[4]-pow(states[3], 4.0)*constants[4]*computedConstants[0]; + rates[0] = (-algebraicVariables[2]-algebraicVariables[1]-externalVariables[0]+algebraicVariables[0])/constants[0]; + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = (1.0-states[2])*algebraicVariables[3]-states[2]*algebraicVariables[4]; + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + rates[1] = (1.0-states[1])*algebraicVariables[5]-states[1]*algebraicVariables[6]; + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + rates[3] = (1.0-states[3])*algebraicVariables[7]-states[3]*algebraicVariables[8]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + double leakage_current_E_L = -10.613+constants[1]; + algebraicVariables[1] = states[0]*constants[2]-constants[2]*leakage_current_E_L; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[2] = states[0]*pow(states[3], 4.0)*constants[4]-pow(states[3], 4.0)*constants[4]*computedConstants[0]; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_windows.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_windows.py new file mode 100644 index 0000000000..a02d541fd3 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants.with.externals_windows.py @@ -0,0 +1,130 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 9 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + leakage_current_E_L = -10.613+constants[1] + algebraic_variables[1] = states[0]*constants[2]-constants[2]*leakage_current_E_L + algebraic_variables[2] = states[0]*pow(states[3], 4.0)*constants[4]-pow(states[3], 4.0)*constants[4]*computed_constants[0] + rates[0] = (-algebraic_variables[2]-algebraic_variables[1]-external_variables[0]+algebraic_variables[0])/constants[0] + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = (1.0-states[2])*algebraic_variables[3]-states[2]*algebraic_variables[4] + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + rates[1] = (1.0-states[1])*algebraic_variables[5]-states[1]*algebraic_variables[6] + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + rates[3] = (1.0-states[3])*algebraic_variables[7]-states[3]*algebraic_variables[8] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + leakage_current_E_L = -10.613+constants[1] + algebraic_variables[1] = states[0]*constants[2]-constants[2]*leakage_current_E_L + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[2] = states[0]*pow(states[3], 4.0)*constants[4]-pow(states[3], 4.0)*constants[4]*computed_constants[0] + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_linux.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_linux.c new file mode 100644 index 0000000000..ced1c30cd0 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_linux.c @@ -0,0 +1,150 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.computed.constants.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + 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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double potassium_channel_E_K = 12.0+constants[1]; + algebraicVariables[2] = -pow(states[3], 4.0)*potassium_channel_E_K*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + double leakage_current_E_L = -10.613+constants[1]; + algebraicVariables[1] = states[0]*constants[2]-leakage_current_E_L*constants[2]; + double sodium_channel_E_Na = -115.0+constants[1]; + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*sodium_channel_E_Na; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[3]-algebraicVariables[1]-algebraicVariables[2])/constants[0]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*algebraicVariables[5]+(1.0-states[2])*algebraicVariables[4]; + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*algebraicVariables[7]+(1.0-states[1])*algebraicVariables[6]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*algebraicVariables[9]+(1.0-states[3])*algebraicVariables[8]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double leakage_current_E_L = -10.613+constants[1]; + algebraicVariables[1] = states[0]*constants[2]-leakage_current_E_L*constants[2]; + double sodium_channel_E_Na = -115.0+constants[1]; + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*sodium_channel_E_Na; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + double potassium_channel_E_K = 12.0+constants[1]; + algebraicVariables[2] = -pow(states[3], 4.0)*potassium_channel_E_K*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_linux.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_linux.py new file mode 100644 index 0000000000..259a271321 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_linux.py @@ -0,0 +1,125 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 10 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + potassium_channel_E_K = 12.0+constants[1] + algebraic_variables[2] = -pow(states[3], 4.0)*potassium_channel_E_K*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + leakage_current_E_L = -10.613+constants[1] + algebraic_variables[1] = states[0]*constants[2]-leakage_current_E_L*constants[2] + sodium_channel_E_Na = -115.0+constants[1] + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*sodium_channel_E_Na + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[3]-algebraic_variables[1]-algebraic_variables[2])/constants[0] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*algebraic_variables[5]+(1.0-states[2])*algebraic_variables[4] + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*algebraic_variables[7]+(1.0-states[1])*algebraic_variables[6] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*algebraic_variables[9]+(1.0-states[3])*algebraic_variables[8] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + leakage_current_E_L = -10.613+constants[1] + algebraic_variables[1] = states[0]*constants[2]-leakage_current_E_L*constants[2] + sodium_channel_E_Na = -115.0+constants[1] + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*sodium_channel_E_Na + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + potassium_channel_E_K = 12.0+constants[1] + algebraic_variables[2] = -pow(states[3], 4.0)*potassium_channel_E_K*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_macos.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_macos.c new file mode 100644 index 0000000000..fd1c001b0f --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_macos.c @@ -0,0 +1,150 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.computed.constants.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + 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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double sodium_channel_E_Na = -115.0+constants[1]; + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*sodium_channel_E_Na; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + double leakage_current_E_L = -10.613+constants[1]; + algebraicVariables[1] = states[0]*constants[2]-leakage_current_E_L*constants[2]; + double potassium_channel_E_K = 12.0+constants[1]; + algebraicVariables[2] = -pow(states[3], 4.0)*potassium_channel_E_K*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + rates[0] = (-algebraicVariables[2]-algebraicVariables[1]+algebraicVariables[0]-algebraicVariables[3])/constants[0]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*algebraicVariables[5]+(1.0-states[2])*algebraicVariables[4]; + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*algebraicVariables[7]+(1.0-states[1])*algebraicVariables[6]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*algebraicVariables[9]+(1.0-states[3])*algebraicVariables[8]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double leakage_current_E_L = -10.613+constants[1]; + algebraicVariables[1] = states[0]*constants[2]-leakage_current_E_L*constants[2]; + double sodium_channel_E_Na = -115.0+constants[1]; + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*sodium_channel_E_Na; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + double potassium_channel_E_K = 12.0+constants[1]; + algebraicVariables[2] = -pow(states[3], 4.0)*potassium_channel_E_K*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_macos.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_macos.py new file mode 100644 index 0000000000..f7a14cbf0f --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_macos.py @@ -0,0 +1,125 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 10 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + sodium_channel_E_Na = -115.0+constants[1] + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*sodium_channel_E_Na + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + leakage_current_E_L = -10.613+constants[1] + algebraic_variables[1] = states[0]*constants[2]-leakage_current_E_L*constants[2] + potassium_channel_E_K = 12.0+constants[1] + algebraic_variables[2] = -pow(states[3], 4.0)*potassium_channel_E_K*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + rates[0] = (-algebraic_variables[2]-algebraic_variables[1]+algebraic_variables[0]-algebraic_variables[3])/constants[0] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*algebraic_variables[5]+(1.0-states[2])*algebraic_variables[4] + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*algebraic_variables[7]+(1.0-states[1])*algebraic_variables[6] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*algebraic_variables[9]+(1.0-states[3])*algebraic_variables[8] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + leakage_current_E_L = -10.613+constants[1] + algebraic_variables[1] = states[0]*constants[2]-leakage_current_E_L*constants[2] + sodium_channel_E_Na = -115.0+constants[1] + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*sodium_channel_E_Na + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + potassium_channel_E_K = 12.0+constants[1] + algebraic_variables[2] = -pow(states[3], 4.0)*potassium_channel_E_K*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_windows.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_windows.c new file mode 100644 index 0000000000..950f64fadc --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_windows.c @@ -0,0 +1,150 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.computed.constants.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + 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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + double leakage_current_E_L = -10.613+constants[1]; + algebraicVariables[1] = states[0]*constants[2]-leakage_current_E_L*constants[2]; + double potassium_channel_E_K = 12.0+constants[1]; + algebraicVariables[2] = -pow(states[3], 4.0)*potassium_channel_E_K*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + double sodium_channel_E_Na = -115.0+constants[1]; + algebraicVariables[3] = -states[1]*pow(states[2], 3.0)*constants[3]*sodium_channel_E_Na+states[0]*states[1]*pow(states[2], 3.0)*constants[3]; + rates[0] = (-algebraicVariables[3]-algebraicVariables[2]-algebraicVariables[1]+algebraicVariables[0])/constants[0]; + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + rates[2] = (1.0-states[2])*algebraicVariables[4]-states[2]*algebraicVariables[5]; + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + rates[1] = (1.0-states[1])*algebraicVariables[6]-states[1]*algebraicVariables[7]; + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + rates[3] = (1.0-states[3])*algebraicVariables[8]-states[3]*algebraicVariables[9]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double leakage_current_E_L = -10.613+constants[1]; + algebraicVariables[1] = states[0]*constants[2]-leakage_current_E_L*constants[2]; + double sodium_channel_E_Na = -115.0+constants[1]; + algebraicVariables[3] = -states[1]*pow(states[2], 3.0)*constants[3]*sodium_channel_E_Na+states[0]*states[1]*pow(states[2], 3.0)*constants[3]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + double potassium_channel_E_K = 12.0+constants[1]; + algebraicVariables[2] = -pow(states[3], 4.0)*potassium_channel_E_K*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_windows.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_windows.py new file mode 100644 index 0000000000..4f7ee9f9ef --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.computed.constants_windows.py @@ -0,0 +1,125 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 10 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + leakage_current_E_L = -10.613+constants[1] + algebraic_variables[1] = states[0]*constants[2]-leakage_current_E_L*constants[2] + potassium_channel_E_K = 12.0+constants[1] + algebraic_variables[2] = -pow(states[3], 4.0)*potassium_channel_E_K*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + sodium_channel_E_Na = -115.0+constants[1] + algebraic_variables[3] = -states[1]*pow(states[2], 3.0)*constants[3]*sodium_channel_E_Na+states[0]*states[1]*pow(states[2], 3.0)*constants[3] + rates[0] = (-algebraic_variables[3]-algebraic_variables[2]-algebraic_variables[1]+algebraic_variables[0])/constants[0] + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + rates[2] = (1.0-states[2])*algebraic_variables[4]-states[2]*algebraic_variables[5] + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + rates[1] = (1.0-states[1])*algebraic_variables[6]-states[1]*algebraic_variables[7] + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + rates[3] = (1.0-states[3])*algebraic_variables[8]-states[3]*algebraic_variables[9] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + leakage_current_E_L = -10.613+constants[1] + algebraic_variables[1] = states[0]*constants[2]-leakage_current_E_L*constants[2] + sodium_channel_E_Na = -115.0+constants[1] + algebraic_variables[3] = -states[1]*pow(states[2], 3.0)*constants[3]*sodium_channel_E_Na+states[0]*states[1]*pow(states[2], 3.0)*constants[3] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + potassium_channel_E_K = 12.0+constants[1] + algebraic_variables[2] = -pow(states[3], 4.0)*potassium_channel_E_K*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[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.variant.untracked.constants.h similarity index 100% rename from tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.h rename to tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.h 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.variant.untracked.constants.with.externals.h similarity index 100% rename from tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.h rename to tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals.h diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_linux.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_linux.c new file mode 100644 index 0000000000..293a3d1bb5 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_linux.c @@ -0,0 +1,162 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.constants.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 1; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 9; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_E_R = 0.0; + computedConstants[0] = -10.613+membrane_E_R; + computedConstants[1] = -115.0+membrane_E_R; + computedConstants[2] = 12.0+membrane_E_R; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + double potassium_channel_g_K = 36.0; + algebraicVariables[2] = -pow(states[3], 4.0)*potassium_channel_g_K*computedConstants[2]+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + double leakage_current_g_L = 0.3; + algebraicVariables[1] = states[0]*leakage_current_g_L-leakage_current_g_L*computedConstants[0]; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-externalVariables[0]-algebraicVariables[1]-algebraicVariables[2])/constants[0]; + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*algebraicVariables[4]+(1.0-states[2])*algebraicVariables[3]; + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*algebraicVariables[6]+(1.0-states[1])*algebraicVariables[5]; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*algebraicVariables[8]+(1.0-states[3])*algebraicVariables[7]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + double leakage_current_g_L = 0.3; + algebraicVariables[1] = states[0]*leakage_current_g_L-leakage_current_g_L*computedConstants[0]; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + double potassium_channel_g_K = 36.0; + algebraicVariables[2] = -pow(states[3], 4.0)*potassium_channel_g_K*computedConstants[2]+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_linux.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_linux.py new file mode 100644 index 0000000000..4f419dbf29 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_linux.py @@ -0,0 +1,129 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 1 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 9 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_E_R = 0.0 + computed_constants[0] = -10.613+membrane_E_R + computed_constants[1] = -115.0+membrane_E_R + computed_constants[2] = 12.0+membrane_E_R + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + potassium_channel_g_K = 36.0 + algebraic_variables[2] = -pow(states[3], 4.0)*potassium_channel_g_K*computed_constants[2]+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + leakage_current_g_L = 0.3 + algebraic_variables[1] = states[0]*leakage_current_g_L-leakage_current_g_L*computed_constants[0] + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-external_variables[0]-algebraic_variables[1]-algebraic_variables[2])/constants[0] + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*algebraic_variables[4]+(1.0-states[2])*algebraic_variables[3] + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*algebraic_variables[6]+(1.0-states[1])*algebraic_variables[5] + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*algebraic_variables[8]+(1.0-states[3])*algebraic_variables[7] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + leakage_current_g_L = 0.3 + algebraic_variables[1] = states[0]*leakage_current_g_L-leakage_current_g_L*computed_constants[0] + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + potassium_channel_g_K = 36.0 + algebraic_variables[2] = -pow(states[3], 4.0)*potassium_channel_g_K*computed_constants[2]+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_macos.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_macos.c new file mode 100644 index 0000000000..eaebdc1afc --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_macos.c @@ -0,0 +1,162 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.constants.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 1; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 9; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_E_R = 0.0; + computedConstants[0] = -10.613+membrane_E_R; + computedConstants[1] = -115.0+membrane_E_R; + computedConstants[2] = 12.0+membrane_E_R; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + double potassium_channel_g_K = 36.0; + algebraicVariables[2] = -pow(states[3], 4.0)*potassium_channel_g_K*computedConstants[2]+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + double leakage_current_g_L = 0.3; + algebraicVariables[1] = states[0]*leakage_current_g_L-leakage_current_g_L*computedConstants[0]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[1]-externalVariables[0]-algebraicVariables[2])/constants[0]; + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*algebraicVariables[4]+(1.0-states[2])*algebraicVariables[3]; + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*algebraicVariables[6]+(1.0-states[1])*algebraicVariables[5]; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*algebraicVariables[8]+(1.0-states[3])*algebraicVariables[7]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + double leakage_current_g_L = 0.3; + algebraicVariables[1] = states[0]*leakage_current_g_L-leakage_current_g_L*computedConstants[0]; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + double potassium_channel_g_K = 36.0; + algebraicVariables[2] = -pow(states[3], 4.0)*potassium_channel_g_K*computedConstants[2]+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_macos.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_macos.py new file mode 100644 index 0000000000..1527aa7343 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_macos.py @@ -0,0 +1,129 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 1 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 9 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_E_R = 0.0 + computed_constants[0] = -10.613+membrane_E_R + computed_constants[1] = -115.0+membrane_E_R + computed_constants[2] = 12.0+membrane_E_R + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + potassium_channel_g_K = 36.0 + algebraic_variables[2] = -pow(states[3], 4.0)*potassium_channel_g_K*computed_constants[2]+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + leakage_current_g_L = 0.3 + algebraic_variables[1] = states[0]*leakage_current_g_L-leakage_current_g_L*computed_constants[0] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[1]-external_variables[0]-algebraic_variables[2])/constants[0] + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*algebraic_variables[4]+(1.0-states[2])*algebraic_variables[3] + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*algebraic_variables[6]+(1.0-states[1])*algebraic_variables[5] + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*algebraic_variables[8]+(1.0-states[3])*algebraic_variables[7] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + leakage_current_g_L = 0.3 + algebraic_variables[1] = states[0]*leakage_current_g_L-leakage_current_g_L*computed_constants[0] + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + potassium_channel_g_K = 36.0 + algebraic_variables[2] = -pow(states[3], 4.0)*potassium_channel_g_K*computed_constants[2]+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_windows.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_windows.c new file mode 100644 index 0000000000..f6e1c4c070 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_windows.c @@ -0,0 +1,162 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.constants.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 1; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 9; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_E_R = 0.0; + computedConstants[0] = -10.613+membrane_E_R; + computedConstants[1] = -115.0+membrane_E_R; + computedConstants[2] = 12.0+membrane_E_R; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + double leakage_current_g_L = 0.3; + algebraicVariables[1] = states[0]*leakage_current_g_L-leakage_current_g_L*computedConstants[0]; + double potassium_channel_g_K = 36.0; + algebraicVariables[2] = states[0]*pow(states[3], 4.0)*potassium_channel_g_K-pow(states[3], 4.0)*potassium_channel_g_K*computedConstants[2]; + rates[0] = (-algebraicVariables[2]-algebraicVariables[1]-externalVariables[0]+algebraicVariables[0])/constants[0]; + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = (1.0-states[2])*algebraicVariables[3]-states[2]*algebraicVariables[4]; + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + rates[1] = (1.0-states[1])*algebraicVariables[5]-states[1]*algebraicVariables[6]; + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + rates[3] = (1.0-states[3])*algebraicVariables[7]-states[3]*algebraicVariables[8]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + double leakage_current_g_L = 0.3; + algebraicVariables[1] = states[0]*leakage_current_g_L-leakage_current_g_L*computedConstants[0]; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + double potassium_channel_g_K = 36.0; + algebraicVariables[2] = states[0]*pow(states[3], 4.0)*potassium_channel_g_K-pow(states[3], 4.0)*potassium_channel_g_K*computedConstants[2]; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_windows.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_windows.py new file mode 100644 index 0000000000..0d1ddfffe6 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants.with.externals_windows.py @@ -0,0 +1,129 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 1 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 9 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_E_R = 0.0 + computed_constants[0] = -10.613+membrane_E_R + computed_constants[1] = -115.0+membrane_E_R + computed_constants[2] = 12.0+membrane_E_R + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + leakage_current_g_L = 0.3 + algebraic_variables[1] = states[0]*leakage_current_g_L-leakage_current_g_L*computed_constants[0] + potassium_channel_g_K = 36.0 + algebraic_variables[2] = states[0]*pow(states[3], 4.0)*potassium_channel_g_K-pow(states[3], 4.0)*potassium_channel_g_K*computed_constants[2] + rates[0] = (-algebraic_variables[2]-algebraic_variables[1]-external_variables[0]+algebraic_variables[0])/constants[0] + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = (1.0-states[2])*algebraic_variables[3]-states[2]*algebraic_variables[4] + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + rates[1] = (1.0-states[1])*algebraic_variables[5]-states[1]*algebraic_variables[6] + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + rates[3] = (1.0-states[3])*algebraic_variables[7]-states[3]*algebraic_variables[8] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + leakage_current_g_L = 0.3 + algebraic_variables[1] = states[0]*leakage_current_g_L-leakage_current_g_L*computed_constants[0] + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + potassium_channel_g_K = 36.0 + algebraic_variables[2] = states[0]*pow(states[3], 4.0)*potassium_channel_g_K-pow(states[3], 4.0)*potassium_channel_g_K*computed_constants[2] + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_linux.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_linux.c new file mode 100644 index 0000000000..c2cbd10200 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_linux.c @@ -0,0 +1,148 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.constants.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + 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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_E_R = 0.0; + computedConstants[0] = -10.613+membrane_E_R; + computedConstants[1] = -115.0+membrane_E_R; + computedConstants[2] = 12.0+membrane_E_R; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_Cm = 1.0; + double potassium_channel_g_K = 36.0; + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + double leakage_current_g_L = 0.3; + algebraicVariables[1] = states[0]*leakage_current_g_L-computedConstants[0]*leakage_current_g_L; + double sodium_channel_g_Na = 120.0; + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na-states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*computedConstants[1]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[3]-algebraicVariables[1]-algebraicVariables[2])/membrane_Cm; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*algebraicVariables[5]+(1.0-states[2])*algebraicVariables[4]; + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*algebraicVariables[7]+(1.0-states[1])*algebraicVariables[6]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*algebraicVariables[9]+(1.0-states[3])*algebraicVariables[8]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double leakage_current_g_L = 0.3; + algebraicVariables[1] = states[0]*leakage_current_g_L-computedConstants[0]*leakage_current_g_L; + double sodium_channel_g_Na = 120.0; + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na-states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*computedConstants[1]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + double potassium_channel_g_K = 36.0; + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_linux.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_linux.py new file mode 100644 index 0000000000..0a7edb2329 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_linux.py @@ -0,0 +1,122 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 10 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_E_R = 0.0 + computed_constants[0] = -10.613+membrane_E_R + computed_constants[1] = -115.0+membrane_E_R + computed_constants[2] = 12.0+membrane_E_R + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_Cm = 1.0 + potassium_channel_g_K = 36.0 + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + leakage_current_g_L = 0.3 + algebraic_variables[1] = states[0]*leakage_current_g_L-computed_constants[0]*leakage_current_g_L + sodium_channel_g_Na = 120.0 + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na-states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*computed_constants[1] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[3]-algebraic_variables[1]-algebraic_variables[2])/membrane_Cm + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*algebraic_variables[5]+(1.0-states[2])*algebraic_variables[4] + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*algebraic_variables[7]+(1.0-states[1])*algebraic_variables[6] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*algebraic_variables[9]+(1.0-states[3])*algebraic_variables[8] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + leakage_current_g_L = 0.3 + algebraic_variables[1] = states[0]*leakage_current_g_L-computed_constants[0]*leakage_current_g_L + sodium_channel_g_Na = 120.0 + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na-states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*computed_constants[1] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + potassium_channel_g_K = 36.0 + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_macos.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_macos.c new file mode 100644 index 0000000000..307f91837d --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_macos.c @@ -0,0 +1,148 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.constants.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + 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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_E_R = 0.0; + computedConstants[0] = -10.613+membrane_E_R; + computedConstants[1] = -115.0+membrane_E_R; + computedConstants[2] = 12.0+membrane_E_R; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_Cm = 1.0; + double sodium_channel_g_Na = 120.0; + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na-states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*computedConstants[1]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + double leakage_current_g_L = 0.3; + algebraicVariables[1] = states[0]*leakage_current_g_L-computedConstants[0]*leakage_current_g_L; + double potassium_channel_g_K = 36.0; + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + rates[0] = (-algebraicVariables[2]-algebraicVariables[1]+algebraicVariables[0]-algebraicVariables[3])/membrane_Cm; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*algebraicVariables[5]+(1.0-states[2])*algebraicVariables[4]; + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*algebraicVariables[7]+(1.0-states[1])*algebraicVariables[6]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*algebraicVariables[9]+(1.0-states[3])*algebraicVariables[8]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double leakage_current_g_L = 0.3; + algebraicVariables[1] = states[0]*leakage_current_g_L-computedConstants[0]*leakage_current_g_L; + double sodium_channel_g_Na = 120.0; + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na-states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*computedConstants[1]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + double potassium_channel_g_K = 36.0; + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_macos.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_macos.py new file mode 100644 index 0000000000..2d35ef0b65 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_macos.py @@ -0,0 +1,122 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 10 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_E_R = 0.0 + computed_constants[0] = -10.613+membrane_E_R + computed_constants[1] = -115.0+membrane_E_R + computed_constants[2] = 12.0+membrane_E_R + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_Cm = 1.0 + sodium_channel_g_Na = 120.0 + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na-states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*computed_constants[1] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + leakage_current_g_L = 0.3 + algebraic_variables[1] = states[0]*leakage_current_g_L-computed_constants[0]*leakage_current_g_L + potassium_channel_g_K = 36.0 + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + rates[0] = (-algebraic_variables[2]-algebraic_variables[1]+algebraic_variables[0]-algebraic_variables[3])/membrane_Cm + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*algebraic_variables[5]+(1.0-states[2])*algebraic_variables[4] + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*algebraic_variables[7]+(1.0-states[1])*algebraic_variables[6] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*algebraic_variables[9]+(1.0-states[3])*algebraic_variables[8] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + leakage_current_g_L = 0.3 + algebraic_variables[1] = states[0]*leakage_current_g_L-computed_constants[0]*leakage_current_g_L + sodium_channel_g_Na = 120.0 + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na-states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*computed_constants[1] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + potassium_channel_g_K = 36.0 + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_windows.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_windows.c new file mode 100644 index 0000000000..4f4a3d51ca --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_windows.c @@ -0,0 +1,148 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.constants.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + 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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_E_R = 0.0; + computedConstants[0] = -10.613+membrane_E_R; + computedConstants[1] = -115.0+membrane_E_R; + computedConstants[2] = 12.0+membrane_E_R; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_Cm = 1.0; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + double leakage_current_g_L = 0.3; + algebraicVariables[1] = states[0]*leakage_current_g_L-computedConstants[0]*leakage_current_g_L; + double potassium_channel_g_K = 36.0; + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + double sodium_channel_g_Na = 120.0; + algebraicVariables[3] = -states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*computedConstants[1]+states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na; + rates[0] = (-algebraicVariables[3]-algebraicVariables[2]-algebraicVariables[1]+algebraicVariables[0])/membrane_Cm; + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + rates[2] = (1.0-states[2])*algebraicVariables[4]-states[2]*algebraicVariables[5]; + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + rates[1] = (1.0-states[1])*algebraicVariables[6]-states[1]*algebraicVariables[7]; + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + rates[3] = (1.0-states[3])*algebraicVariables[8]-states[3]*algebraicVariables[9]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double leakage_current_g_L = 0.3; + algebraicVariables[1] = states[0]*leakage_current_g_L-computedConstants[0]*leakage_current_g_L; + double sodium_channel_g_Na = 120.0; + algebraicVariables[3] = -states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*computedConstants[1]+states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + double potassium_channel_g_K = 36.0; + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_windows.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_windows.py new file mode 100644 index 0000000000..a3c967233e --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.constants_windows.py @@ -0,0 +1,122 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 10 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_E_R = 0.0 + computed_constants[0] = -10.613+membrane_E_R + computed_constants[1] = -115.0+membrane_E_R + computed_constants[2] = 12.0+membrane_E_R + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_Cm = 1.0 + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + leakage_current_g_L = 0.3 + algebraic_variables[1] = states[0]*leakage_current_g_L-computed_constants[0]*leakage_current_g_L + potassium_channel_g_K = 36.0 + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + sodium_channel_g_Na = 120.0 + algebraic_variables[3] = -states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*computed_constants[1]+states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na + rates[0] = (-algebraic_variables[3]-algebraic_variables[2]-algebraic_variables[1]+algebraic_variables[0])/membrane_Cm + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + rates[2] = (1.0-states[2])*algebraic_variables[4]-states[2]*algebraic_variables[5] + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + rates[1] = (1.0-states[1])*algebraic_variables[6]-states[1]*algebraic_variables[7] + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + rates[3] = (1.0-states[3])*algebraic_variables[8]-states[3]*algebraic_variables[9] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + leakage_current_g_L = 0.3 + algebraic_variables[1] = states[0]*leakage_current_g_L-computed_constants[0]*leakage_current_g_L + sodium_channel_g_Na = 120.0 + algebraic_variables[3] = -states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*computed_constants[1]+states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + potassium_channel_g_K = 36.0 + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) 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.variant.untracked.control.h similarity index 100% rename from tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.h rename to tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.h 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.variant.untracked.control.with.externals.h similarity index 100% rename from tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.h rename to tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals.h diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_linux.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_linux.c new file mode 100644 index 0000000000..ed6dd9e51d --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_linux.c @@ -0,0 +1,165 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.control.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 9; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[2] = -pow(states[3], 4.0)*constants[4]*computedConstants[2]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[1] = states[0]*constants[2]-constants[2]*computedConstants[0]; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-externalVariables[0]-algebraicVariables[1]-algebraicVariables[2])/constants[0]; + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*algebraicVariables[4]+(1.0-states[2])*algebraicVariables[3]; + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*algebraicVariables[6]+(1.0-states[1])*algebraicVariables[5]; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*algebraicVariables[8]+(1.0-states[3])*algebraicVariables[7]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[1] = states[0]*constants[2]-constants[2]*computedConstants[0]; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[2] = -pow(states[3], 4.0)*constants[4]*computedConstants[2]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_linux.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_linux.py new file mode 100644 index 0000000000..3e5ba62024 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_linux.py @@ -0,0 +1,132 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 9 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[2] = -pow(states[3], 4.0)*constants[4]*computed_constants[2]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[1] = states[0]*constants[2]-constants[2]*computed_constants[0] + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-external_variables[0]-algebraic_variables[1]-algebraic_variables[2])/constants[0] + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*algebraic_variables[4]+(1.0-states[2])*algebraic_variables[3] + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*algebraic_variables[6]+(1.0-states[1])*algebraic_variables[5] + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*algebraic_variables[8]+(1.0-states[3])*algebraic_variables[7] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[1] = states[0]*constants[2]-constants[2]*computed_constants[0] + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[2] = -pow(states[3], 4.0)*constants[4]*computed_constants[2]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_macos.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_macos.c new file mode 100644 index 0000000000..c5188648a7 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_macos.c @@ -0,0 +1,165 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.control.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 9; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[2] = -pow(states[3], 4.0)*constants[4]*computedConstants[2]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[1] = states[0]*constants[2]-constants[2]*computedConstants[0]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[1]-externalVariables[0]-algebraicVariables[2])/constants[0]; + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*algebraicVariables[4]+(1.0-states[2])*algebraicVariables[3]; + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*algebraicVariables[6]+(1.0-states[1])*algebraicVariables[5]; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*algebraicVariables[8]+(1.0-states[3])*algebraicVariables[7]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[1] = states[0]*constants[2]-constants[2]*computedConstants[0]; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[2] = -pow(states[3], 4.0)*constants[4]*computedConstants[2]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_macos.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_macos.py new file mode 100644 index 0000000000..d2b36949ee --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_macos.py @@ -0,0 +1,132 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 9 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[2] = -pow(states[3], 4.0)*constants[4]*computed_constants[2]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[1] = states[0]*constants[2]-constants[2]*computed_constants[0] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[1]-external_variables[0]-algebraic_variables[2])/constants[0] + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*algebraic_variables[4]+(1.0-states[2])*algebraic_variables[3] + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*algebraic_variables[6]+(1.0-states[1])*algebraic_variables[5] + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*algebraic_variables[8]+(1.0-states[3])*algebraic_variables[7] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[1] = states[0]*constants[2]-constants[2]*computed_constants[0] + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[2] = -pow(states[3], 4.0)*constants[4]*computed_constants[2]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_windows.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_windows.c new file mode 100644 index 0000000000..59667f0367 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_windows.c @@ -0,0 +1,165 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.control.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 9; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[1] = states[0]*constants[2]-constants[2]*computedConstants[0]; + algebraicVariables[2] = states[0]*pow(states[3], 4.0)*constants[4]-pow(states[3], 4.0)*constants[4]*computedConstants[2]; + rates[0] = (-algebraicVariables[2]-algebraicVariables[1]-externalVariables[0]+algebraicVariables[0])/constants[0]; + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = (1.0-states[2])*algebraicVariables[3]-states[2]*algebraicVariables[4]; + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + rates[1] = (1.0-states[1])*algebraicVariables[5]-states[1]*algebraicVariables[6]; + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + rates[3] = (1.0-states[3])*algebraicVariables[7]-states[3]*algebraicVariables[8]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[1] = states[0]*constants[2]-constants[2]*computedConstants[0]; + algebraicVariables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[4] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[5] = 0.07*exp(0.05*states[0]); + algebraicVariables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[2] = states[0]*pow(states[3], 4.0)*constants[4]-pow(states[3], 4.0)*constants[4]*computedConstants[2]; + algebraicVariables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[8] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_windows.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_windows.py new file mode 100644 index 0000000000..de03db5e6d --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control.with.externals_windows.py @@ -0,0 +1,132 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 9 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[1] = states[0]*constants[2]-constants[2]*computed_constants[0] + algebraic_variables[2] = states[0]*pow(states[3], 4.0)*constants[4]-pow(states[3], 4.0)*constants[4]*computed_constants[2] + rates[0] = (-algebraic_variables[2]-algebraic_variables[1]-external_variables[0]+algebraic_variables[0])/constants[0] + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = (1.0-states[2])*algebraic_variables[3]-states[2]*algebraic_variables[4] + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + rates[1] = (1.0-states[1])*algebraic_variables[5]-states[1]*algebraic_variables[6] + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + rates[3] = (1.0-states[3])*algebraic_variables[7]-states[3]*algebraic_variables[8] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[1] = states[0]*constants[2]-constants[2]*computed_constants[0] + algebraic_variables[3] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[4] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[5] = 0.07*exp(0.05*states[0]) + algebraic_variables[6] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[2] = states[0]*pow(states[3], 4.0)*constants[4]-pow(states[3], 4.0)*constants[4]*computed_constants[2] + algebraic_variables[7] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[8] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_linux.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_linux.c new file mode 100644 index 0000000000..21277696fe --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_linux.c @@ -0,0 +1,150 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.control.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + 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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[1] = states[0]*constants[2]-computedConstants[0]*constants[2]; + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[3]-algebraicVariables[1]-algebraicVariables[2])/constants[0]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*algebraicVariables[5]+(1.0-states[2])*algebraicVariables[4]; + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*algebraicVariables[7]+(1.0-states[1])*algebraicVariables[6]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*algebraicVariables[9]+(1.0-states[3])*algebraicVariables[8]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[1] = states[0]*constants[2]-computedConstants[0]*constants[2]; + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_linux.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_linux.py new file mode 100644 index 0000000000..7ff50d57d8 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_linux.py @@ -0,0 +1,124 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 10 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[1] = states[0]*constants[2]-computed_constants[0]*constants[2] + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[3]-algebraic_variables[1]-algebraic_variables[2])/constants[0] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*algebraic_variables[5]+(1.0-states[2])*algebraic_variables[4] + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*algebraic_variables[7]+(1.0-states[1])*algebraic_variables[6] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*algebraic_variables[9]+(1.0-states[3])*algebraic_variables[8] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[1] = states[0]*constants[2]-computed_constants[0]*constants[2] + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_macos.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_macos.c new file mode 100644 index 0000000000..220e60bba1 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_macos.c @@ -0,0 +1,150 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.control.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + 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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraicVariables[1] = states[0]*constants[2]-computedConstants[0]*constants[2]; + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + rates[0] = (-algebraicVariables[2]-algebraicVariables[1]+algebraicVariables[0]-algebraicVariables[3])/constants[0]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*algebraicVariables[5]+(1.0-states[2])*algebraicVariables[4]; + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*algebraicVariables[7]+(1.0-states[1])*algebraicVariables[6]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*algebraicVariables[9]+(1.0-states[3])*algebraicVariables[8]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[1] = states[0]*constants[2]-computedConstants[0]*constants[2]; + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_macos.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_macos.py new file mode 100644 index 0000000000..f8a2fb6521 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_macos.py @@ -0,0 +1,124 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 10 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic_variables[1] = states[0]*constants[2]-computed_constants[0]*constants[2] + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + rates[0] = (-algebraic_variables[2]-algebraic_variables[1]+algebraic_variables[0]-algebraic_variables[3])/constants[0] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*algebraic_variables[5]+(1.0-states[2])*algebraic_variables[4] + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*algebraic_variables[7]+(1.0-states[1])*algebraic_variables[6] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*algebraic_variables[9]+(1.0-states[3])*algebraic_variables[8] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[1] = states[0]*constants[2]-computed_constants[0]*constants[2] + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_windows.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_windows.c new file mode 100644 index 0000000000..6217903d6e --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_windows.c @@ -0,0 +1,150 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.control.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + 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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraicVariables[1] = states[0]*constants[2]-computedConstants[0]*constants[2]; + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[3] = -states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]+states[0]*states[1]*pow(states[2], 3.0)*constants[3]; + rates[0] = (-algebraicVariables[3]-algebraicVariables[2]-algebraicVariables[1]+algebraicVariables[0])/constants[0]; + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + rates[2] = (1.0-states[2])*algebraicVariables[4]-states[2]*algebraicVariables[5]; + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + rates[1] = (1.0-states[1])*algebraicVariables[6]-states[1]*algebraicVariables[7]; + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + rates[3] = (1.0-states[3])*algebraicVariables[8]-states[3]*algebraicVariables[9]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[1] = states[0]*constants[2]-computedConstants[0]*constants[2]; + algebraicVariables[3] = -states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]+states[0]*states[1]*pow(states[2], 3.0)*constants[3]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_windows.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_windows.py new file mode 100644 index 0000000000..143f252c62 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.control_windows.py @@ -0,0 +1,124 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 10 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic_variables[1] = states[0]*constants[2]-computed_constants[0]*constants[2] + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[3] = -states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1]+states[0]*states[1]*pow(states[2], 3.0)*constants[3] + rates[0] = (-algebraic_variables[3]-algebraic_variables[2]-algebraic_variables[1]+algebraic_variables[0])/constants[0] + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + rates[2] = (1.0-states[2])*algebraic_variables[4]-states[2]*algebraic_variables[5] + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + rates[1] = (1.0-states[1])*algebraic_variables[6]-states[1]*algebraic_variables[7] + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + rates[3] = (1.0-states[3])*algebraic_variables[8]-states[3]*algebraic_variables[9] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[1] = states[0]*constants[2]-computed_constants[0]*constants[2] + algebraic_variables[3] = -states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1]+states[0]*states[1]*pow(states[2], 3.0)*constants[3] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.h new file mode 100644 index 0000000000..ec5c63b85f --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[5]; + char units[14]; + char component[25]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +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.variant.untracked.variables.with.externals.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals.h new file mode 100644 index 0000000000..60c0a729bb --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals.h @@ -0,0 +1,42 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; + +typedef struct { + char name[8]; + char units[16]; + char component[25]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; +extern const VariableInfo EXTERNAL_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); + +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 voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +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.variant.untracked.variables.with.externals_linux.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_linux.c new file mode 100644 index 0000000000..6d6f5072c1 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_linux.c @@ -0,0 +1,143 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.variables.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 1; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_E_R = 0.0; + computedConstants[0] = 12.0+membrane_E_R; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + double potassium_channel_g_K = 36.0; + double potassium_channel_i_K = -pow(states[3], 4.0)*potassium_channel_g_K*computedConstants[0]+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + double leakage_current_g_L = 0.3; + double membrane_E_R = 0.0; + double leakage_current_E_L = -10.613+membrane_E_R; + double leakage_current_i_L = states[0]*leakage_current_g_L-leakage_current_g_L*leakage_current_E_L; + algebraicVariables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (membrane_i_Stim-externalVariables[0]-leakage_current_i_L-potassium_channel_i_K)/constants[0]; + double sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*algebraicVariables[0]; + double sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]); + double sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h; + double potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + double potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_linux.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_linux.py new file mode 100644 index 0000000000..aaa4e96774 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_linux.py @@ -0,0 +1,110 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 1 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 1 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_E_R = 0.0 + computed_constants[0] = 12.0+membrane_E_R + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + potassium_channel_g_K = 36.0 + potassium_channel_i_K = -pow(states[3], 4.0)*potassium_channel_g_K*computed_constants[0]+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + leakage_current_g_L = 0.3 + membrane_E_R = 0.0 + leakage_current_E_L = -10.613+membrane_E_R + leakage_current_i_L = states[0]*leakage_current_g_L-leakage_current_g_L*leakage_current_E_L + algebraic_variables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (membrane_i_Stim-external_variables[0]-leakage_current_i_L-potassium_channel_i_K)/constants[0] + sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*algebraic_variables[0] + sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]) + sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h + potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_macos.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_macos.c new file mode 100644 index 0000000000..bf0d9be0ca --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_macos.c @@ -0,0 +1,143 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.variables.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 1; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_E_R = 0.0; + computedConstants[0] = 12.0+membrane_E_R; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + double potassium_channel_g_K = 36.0; + double potassium_channel_i_K = -pow(states[3], 4.0)*potassium_channel_g_K*computedConstants[0]+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + algebraicVariables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + double leakage_current_g_L = 0.3; + double membrane_E_R = 0.0; + double leakage_current_E_L = -10.613+membrane_E_R; + double leakage_current_i_L = states[0]*leakage_current_g_L-leakage_current_g_L*leakage_current_E_L; + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (membrane_i_Stim-leakage_current_i_L-externalVariables[0]-potassium_channel_i_K)/constants[0]; + double sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*algebraicVariables[0]; + double sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]); + double sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h; + double potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + double potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_macos.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_macos.py new file mode 100644 index 0000000000..562832a716 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_macos.py @@ -0,0 +1,110 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 1 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 1 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_E_R = 0.0 + computed_constants[0] = 12.0+membrane_E_R + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + potassium_channel_g_K = 36.0 + potassium_channel_i_K = -pow(states[3], 4.0)*potassium_channel_g_K*computed_constants[0]+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + algebraic_variables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + leakage_current_g_L = 0.3 + membrane_E_R = 0.0 + leakage_current_E_L = -10.613+membrane_E_R + leakage_current_i_L = states[0]*leakage_current_g_L-leakage_current_g_L*leakage_current_E_L + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (membrane_i_Stim-leakage_current_i_L-external_variables[0]-potassium_channel_i_K)/constants[0] + sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*algebraic_variables[0] + sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]) + sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h + potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_windows.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_windows.c new file mode 100644 index 0000000000..438e814552 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_windows.c @@ -0,0 +1,143 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.variables.with.externals.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 1; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"i_Na", "microA_per_cm2", "sodium_channel"} +}; + +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; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_E_R = 0.0; + computedConstants[0] = 12.0+membrane_E_R; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraicVariables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + double leakage_current_g_L = 0.3; + double membrane_E_R = 0.0; + double leakage_current_E_L = -10.613+membrane_E_R; + double leakage_current_i_L = states[0]*leakage_current_g_L-leakage_current_g_L*leakage_current_E_L; + double potassium_channel_g_K = 36.0; + double potassium_channel_i_K = states[0]*pow(states[3], 4.0)*potassium_channel_g_K-pow(states[3], 4.0)*potassium_channel_g_K*computedConstants[0]; + rates[0] = (-potassium_channel_i_K-leakage_current_i_L-externalVariables[0]+membrane_i_Stim)/constants[0]; + double sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = (1.0-states[2])*algebraicVariables[0]-states[2]*sodium_channel_m_gate_beta_m; + double sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])); + double sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]); + rates[1] = (1.0-states[1])*sodium_channel_h_gate_alpha_h-states[1]*sodium_channel_h_gate_beta_h; + double potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]); + double potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + rates[3] = (1.0-states[3])*potassium_channel_n_gate_alpha_n-states[3]*potassium_channel_n_gate_beta_n; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + algebraicVariables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_windows.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_windows.py new file mode 100644 index 0000000000..088db48e36 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables.with.externals_windows.py @@ -0,0 +1,110 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 1 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 1 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_E_R = 0.0 + computed_constants[0] = 12.0+membrane_E_R + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic_variables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + leakage_current_g_L = 0.3 + membrane_E_R = 0.0 + leakage_current_E_L = -10.613+membrane_E_R + leakage_current_i_L = states[0]*leakage_current_g_L-leakage_current_g_L*leakage_current_E_L + potassium_channel_g_K = 36.0 + potassium_channel_i_K = states[0]*pow(states[3], 4.0)*potassium_channel_g_K-pow(states[3], 4.0)*potassium_channel_g_K*computed_constants[0] + rates[0] = (-potassium_channel_i_K-leakage_current_i_L-external_variables[0]+membrane_i_Stim)/constants[0] + sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = (1.0-states[2])*algebraic_variables[0]-states[2]*sodium_channel_m_gate_beta_m + sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])) + sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]) + rates[1] = (1.0-states[1])*sodium_channel_h_gate_alpha_h-states[1]*sodium_channel_h_gate_beta_h + potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]) + potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + rates[3] = (1.0-states[3])*potassium_channel_n_gate_alpha_n-states[3]*potassium_channel_n_gate_beta_n + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraic_variables[0] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_linux.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_linux.c new file mode 100644 index 0000000000..8d7fa62c85 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_linux.c @@ -0,0 +1,123 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.variables.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_Cm = 1.0; + double potassium_channel_g_K = 36.0; + double membrane_E_R = 0.0; + double potassium_channel_E_K = 12.0+membrane_E_R; + double potassium_channel_i_K = -pow(states[3], 4.0)*potassium_channel_E_K*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + double leakage_current_g_L = 0.3; + double leakage_current_E_L = -10.613+membrane_E_R; + double leakage_current_i_L = states[0]*leakage_current_g_L-leakage_current_E_L*leakage_current_g_L; + double sodium_channel_g_Na = 120.0; + double sodium_channel_E_Na = -115.0+membrane_E_R; + double sodium_channel_i_Na = states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na-states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*sodium_channel_E_Na; + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (membrane_i_Stim-sodium_channel_i_Na-leakage_current_i_L-potassium_channel_i_K)/membrane_Cm; + double sodium_channel_m_gate_alpha_m = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + double sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*sodium_channel_m_gate_alpha_m; + double sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]); + double sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h; + double potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + double potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n; +} + +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.variant.untracked.variables_linux.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_linux.py new file mode 100644 index 0000000000..180caed08b --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_linux.py @@ -0,0 +1,99 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_Cm = 1.0 + potassium_channel_g_K = 36.0 + membrane_E_R = 0.0 + potassium_channel_E_K = 12.0+membrane_E_R + potassium_channel_i_K = -pow(states[3], 4.0)*potassium_channel_E_K*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + leakage_current_g_L = 0.3 + leakage_current_E_L = -10.613+membrane_E_R + leakage_current_i_L = states[0]*leakage_current_g_L-leakage_current_E_L*leakage_current_g_L + sodium_channel_g_Na = 120.0 + sodium_channel_E_Na = -115.0+membrane_E_R + sodium_channel_i_Na = states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na-states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*sodium_channel_E_Na + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (membrane_i_Stim-sodium_channel_i_Na-leakage_current_i_L-potassium_channel_i_K)/membrane_Cm + sodium_channel_m_gate_alpha_m = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*sodium_channel_m_gate_alpha_m + sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]) + sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h + potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_macos.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_macos.c new file mode 100644 index 0000000000..ce270dcf74 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_macos.c @@ -0,0 +1,123 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.variables.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_Cm = 1.0; + double sodium_channel_g_Na = 120.0; + double membrane_E_R = 0.0; + double sodium_channel_E_Na = -115.0+membrane_E_R; + double sodium_channel_i_Na = states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na-states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*sodium_channel_E_Na; + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + double leakage_current_g_L = 0.3; + double leakage_current_E_L = -10.613+membrane_E_R; + double leakage_current_i_L = states[0]*leakage_current_g_L-leakage_current_E_L*leakage_current_g_L; + double potassium_channel_g_K = 36.0; + double potassium_channel_E_K = 12.0+membrane_E_R; + double potassium_channel_i_K = -pow(states[3], 4.0)*potassium_channel_E_K*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + rates[0] = (-potassium_channel_i_K-leakage_current_i_L+membrane_i_Stim-sodium_channel_i_Na)/membrane_Cm; + double sodium_channel_m_gate_alpha_m = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + double sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*sodium_channel_m_gate_alpha_m; + double sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]); + double sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h; + double potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + double potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n; +} + +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.variant.untracked.variables_macos.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_macos.py new file mode 100644 index 0000000000..8e6d50750c --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_macos.py @@ -0,0 +1,99 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_Cm = 1.0 + sodium_channel_g_Na = 120.0 + membrane_E_R = 0.0 + sodium_channel_E_Na = -115.0+membrane_E_R + sodium_channel_i_Na = states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na-states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*sodium_channel_E_Na + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + leakage_current_g_L = 0.3 + leakage_current_E_L = -10.613+membrane_E_R + leakage_current_i_L = states[0]*leakage_current_g_L-leakage_current_E_L*leakage_current_g_L + potassium_channel_g_K = 36.0 + potassium_channel_E_K = 12.0+membrane_E_R + potassium_channel_i_K = -pow(states[3], 4.0)*potassium_channel_E_K*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + rates[0] = (-potassium_channel_i_K-leakage_current_i_L+membrane_i_Stim-sodium_channel_i_Na)/membrane_Cm + sodium_channel_m_gate_alpha_m = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*sodium_channel_m_gate_beta_m+(1.0-states[2])*sodium_channel_m_gate_alpha_m + sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]) + sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*sodium_channel_h_gate_beta_h+(1.0-states[1])*sodium_channel_h_gate_alpha_h + potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*potassium_channel_n_gate_beta_n+(1.0-states[3])*potassium_channel_n_gate_alpha_n + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_windows.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_windows.c new file mode 100644 index 0000000000..52aa53702b --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_windows.c @@ -0,0 +1,123 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.untracked.variables.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double membrane_Cm = 1.0; + double membrane_i_Stim = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + double leakage_current_g_L = 0.3; + double membrane_E_R = 0.0; + double leakage_current_E_L = -10.613+membrane_E_R; + double leakage_current_i_L = states[0]*leakage_current_g_L-leakage_current_E_L*leakage_current_g_L; + double potassium_channel_g_K = 36.0; + double potassium_channel_E_K = 12.0+membrane_E_R; + double potassium_channel_i_K = -pow(states[3], 4.0)*potassium_channel_E_K*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K; + double sodium_channel_g_Na = 120.0; + double sodium_channel_E_Na = -115.0+membrane_E_R; + double sodium_channel_i_Na = -states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*sodium_channel_E_Na+states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na; + rates[0] = (-sodium_channel_i_Na-potassium_channel_i_K-leakage_current_i_L+membrane_i_Stim)/membrane_Cm; + double sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]); + double sodium_channel_m_gate_alpha_m = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + rates[2] = (1.0-states[2])*sodium_channel_m_gate_alpha_m-states[2]*sodium_channel_m_gate_beta_m; + double sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])); + double sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]); + rates[1] = (1.0-states[1])*sodium_channel_h_gate_alpha_h-states[1]*sodium_channel_h_gate_beta_h; + double potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]); + double potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + rates[3] = (1.0-states[3])*potassium_channel_n_gate_alpha_n-states[3]*potassium_channel_n_gate_beta_n; +} + +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.variant.untracked.variables_windows.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_windows.py new file mode 100644 index 0000000000..8363e402b5 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant.untracked.variables_windows.py @@ -0,0 +1,99 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + membrane_Cm = 1.0 + membrane_i_Stim = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + leakage_current_g_L = 0.3 + membrane_E_R = 0.0 + leakage_current_E_L = -10.613+membrane_E_R + leakage_current_i_L = states[0]*leakage_current_g_L-leakage_current_E_L*leakage_current_g_L + potassium_channel_g_K = 36.0 + potassium_channel_E_K = 12.0+membrane_E_R + potassium_channel_i_K = -pow(states[3], 4.0)*potassium_channel_E_K*potassium_channel_g_K+states[0]*pow(states[3], 4.0)*potassium_channel_g_K + sodium_channel_g_Na = 120.0 + sodium_channel_E_Na = -115.0+membrane_E_R + sodium_channel_i_Na = -states[1]*pow(states[2], 3.0)*sodium_channel_g_Na*sodium_channel_E_Na+states[0]*states[1]*pow(states[2], 3.0)*sodium_channel_g_Na + rates[0] = (-sodium_channel_i_Na-potassium_channel_i_K-leakage_current_i_L+membrane_i_Stim)/membrane_Cm + sodium_channel_m_gate_beta_m = 4.0*exp(0.0555555555555556*states[0]) + sodium_channel_m_gate_alpha_m = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + rates[2] = (1.0-states[2])*sodium_channel_m_gate_alpha_m-states[2]*sodium_channel_m_gate_beta_m + sodium_channel_h_gate_beta_h = 1.0/(1.0+exp(3.0+0.1*states[0])) + sodium_channel_h_gate_alpha_h = 0.07*exp(0.05*states[0]) + rates[1] = (1.0-states[1])*sodium_channel_h_gate_alpha_h-states[1]*sodium_channel_h_gate_beta_h + potassium_channel_n_gate_beta_n = 0.125*exp(0.0125*states[0]) + potassium_channel_n_gate_alpha_n = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + rates[3] = (1.0-states[3])*potassium_channel_n_gate_alpha_n-states[3]*potassium_channel_n_gate_beta_n + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_linux.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_linux.c new file mode 100644 index 0000000000..1abc533f6e --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_linux.c @@ -0,0 +1,150 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + 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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[1] = states[0]*constants[2]-computedConstants[0]*constants[2]; + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + rates[0] = (algebraicVariables[0]-algebraicVariables[3]-algebraicVariables[1]-algebraicVariables[2])/constants[0]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*algebraicVariables[5]+(1.0-states[2])*algebraicVariables[4]; + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*algebraicVariables[7]+(1.0-states[1])*algebraicVariables[6]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*algebraicVariables[9]+(1.0-states[3])*algebraicVariables[8]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[1] = states[0]*constants[2]-computedConstants[0]*constants[2]; + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_linux.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_linux.py new file mode 100644 index 0000000000..7ff50d57d8 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_linux.py @@ -0,0 +1,124 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 10 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[1] = states[0]*constants[2]-computed_constants[0]*constants[2] + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + rates[0] = (algebraic_variables[0]-algebraic_variables[3]-algebraic_variables[1]-algebraic_variables[2])/constants[0] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*algebraic_variables[5]+(1.0-states[2])*algebraic_variables[4] + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*algebraic_variables[7]+(1.0-states[1])*algebraic_variables[6] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*algebraic_variables[9]+(1.0-states[3])*algebraic_variables[8] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[1] = states[0]*constants[2]-computed_constants[0]*constants[2] + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_macos.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_macos.c new file mode 100644 index 0000000000..efb78f97e7 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_macos.c @@ -0,0 +1,150 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + 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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraicVariables[1] = states[0]*constants[2]-computedConstants[0]*constants[2]; + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + rates[0] = (-algebraicVariables[2]-algebraicVariables[1]+algebraicVariables[0]-algebraicVariables[3])/constants[0]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + rates[2] = -states[2]*algebraicVariables[5]+(1.0-states[2])*algebraicVariables[4]; + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + rates[1] = -states[1]*algebraicVariables[7]+(1.0-states[1])*algebraicVariables[6]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); + rates[3] = -states[3]*algebraicVariables[9]+(1.0-states[3])*algebraicVariables[8]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[1] = states[0]*constants[2]-computedConstants[0]*constants[2]; + algebraicVariables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.cellml b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_macos.cellml similarity index 94% rename from tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.cellml rename to tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_macos.cellml index b7a4386f0d..a8a773880c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.cellml +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_macos.cellml @@ -164,35 +164,39 @@ - alpha_m - + + alpha_m - - 0.1 + - - V - 25 + + 0.1 + + + V + 25 + - - - - + - + - - V - 25 + + + + V + 25 + + 10 - 10 + 1 - 1 + 0 @@ -346,12 +350,16 @@ - E_K - - E_R - 12 + + E_K + + + E_R + 12 + + 0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_macos.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_macos.py new file mode 100644 index 0000000000..f8a2fb6521 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_macos.py @@ -0,0 +1,124 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 10 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1] + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic_variables[1] = states[0]*constants[2]-computed_constants[0]*constants[2] + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + rates[0] = (-algebraic_variables[2]-algebraic_variables[1]+algebraic_variables[0]-algebraic_variables[3])/constants[0] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + rates[2] = -states[2]*algebraic_variables[5]+(1.0-states[2])*algebraic_variables[4] + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + rates[1] = -states[1]*algebraic_variables[7]+(1.0-states[1])*algebraic_variables[6] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) + rates[3] = -states[3]*algebraic_variables[9]+(1.0-states[3])*algebraic_variables[8] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[1] = states[0]*constants[2]-computed_constants[0]*constants[2] + algebraic_variables[3] = states[0]*states[1]*pow(states[2], 3.0)*constants[3]-states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_windows.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_windows.c new file mode 100644 index 0000000000..e12de26036 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_windows.c @@ -0,0 +1,150 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.variant.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 4; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + 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) +{ + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[0] = -10.613+constants[1]; + computedConstants[1] = -115.0+constants[1]; + computedConstants[2] = 12.0+constants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraicVariables[1] = states[0]*constants[2]-computedConstants[0]*constants[2]; + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[3] = -states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]+states[0]*states[1]*pow(states[2], 3.0)*constants[3]; + rates[0] = (-algebraicVariables[3]-algebraicVariables[2]-algebraicVariables[1]+algebraicVariables[0])/constants[0]; + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + rates[2] = (1.0-states[2])*algebraicVariables[4]-states[2]*algebraicVariables[5]; + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + rates[1] = (1.0-states[1])*algebraicVariables[6]-states[1]*algebraicVariables[7]; + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + rates[3] = (1.0-states[3])*algebraicVariables[8]-states[3]*algebraicVariables[9]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[1] = states[0]*constants[2]-computedConstants[0]*constants[2]; + algebraicVariables[3] = -states[1]*pow(states[2], 3.0)*constants[3]*computedConstants[1]+states[0]*states[1]*pow(states[2], 3.0)*constants[3]; + algebraicVariables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])); + algebraicVariables[5] = 4.0*exp(0.0555555555555556*states[0]); + algebraicVariables[6] = 0.07*exp(0.05*states[0]); + algebraicVariables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])); + algebraicVariables[2] = -pow(states[3], 4.0)*computedConstants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4]; + algebraicVariables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])); + algebraicVariables[9] = 0.125*exp(0.0125*states[0]); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_windows.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_windows.py new file mode 100644 index 0000000000..143f252c62 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.variant_windows.py @@ -0,0 +1,124 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 4 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 10 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[0] = -10.613+constants[1] + computed_constants[1] = -115.0+constants[1] + computed_constants[2] = 12.0+constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic_variables[1] = states[0]*constants[2]-computed_constants[0]*constants[2] + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[3] = -states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1]+states[0]*states[1]*pow(states[2], 3.0)*constants[3] + rates[0] = (-algebraic_variables[3]-algebraic_variables[2]-algebraic_variables[1]+algebraic_variables[0])/constants[0] + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + rates[2] = (1.0-states[2])*algebraic_variables[4]-states[2]*algebraic_variables[5] + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + rates[1] = (1.0-states[1])*algebraic_variables[6]-states[1]*algebraic_variables[7] + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + rates[3] = (1.0-states[3])*algebraic_variables[8]-states[3]*algebraic_variables[9] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[1] = states[0]*constants[2]-computed_constants[0]*constants[2] + algebraic_variables[3] = -states[1]*pow(states[2], 3.0)*constants[3]*computed_constants[1]+states[0]*states[1]*pow(states[2], 3.0)*constants[3] + algebraic_variables[4] = 0.1*states[0]/(-1.0+exp(2.5+0.1*states[0]))+2.5/(-1.0+exp(2.5+0.1*states[0])) + algebraic_variables[5] = 4.0*exp(0.0555555555555556*states[0]) + algebraic_variables[6] = 0.07*exp(0.05*states[0]) + algebraic_variables[7] = 1.0/(1.0+exp(3.0+0.1*states[0])) + algebraic_variables[2] = -pow(states[3], 4.0)*computed_constants[2]*constants[4]+states[0]*pow(states[3], 4.0)*constants[4] + algebraic_variables[8] = 0.01*states[0]/(-1.0+exp(1.0+0.1*states[0]))+0.1/(-1.0+exp(1.0+0.1*states[0])) + algebraic_variables[9] = 0.125*exp(0.0125*states[0]) diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index 27662b2a8a..1531016cf7 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -117,12 +117,12 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { algebraicVariables[0] = constants[2]*(states[0]-constants[1]); - algebraicVariables[3] = pow(states[2], 3.0)*states[1]*constants[3]; - algebraicVariables[2] = (algebraicVariables[3]+0.14)*(states[0]-constants[4]); algebraicVariables[8] = 1.2*pow(states[3], 4.0); algebraicVariables[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); algebraicVariables[1] = (algebraicVariables[9]+algebraicVariables[8])*(states[0]+100.0); - rates[0] = -(algebraicVariables[2]+algebraicVariables[1]+algebraicVariables[0])/constants[0]; + algebraicVariables[3] = pow(states[2], 3.0)*states[1]*constants[3]; + algebraicVariables[2] = (algebraicVariables[3]+0.14)*(states[0]-constants[4]); + rates[0] = (-algebraicVariables[2]-algebraicVariables[1]-algebraicVariables[0])/constants[0]; algebraicVariables[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); algebraicVariables[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2]; diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 87cfd8dd55..d1777935fe 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -82,12 +82,12 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): algebraic_variables[0] = constants[2]*(states[0]-constants[1]) - algebraic_variables[3] = pow(states[2], 3.0)*states[1]*constants[3] - algebraic_variables[2] = (algebraic_variables[3]+0.14)*(states[0]-constants[4]) algebraic_variables[8] = 1.2*pow(states[3], 4.0) algebraic_variables[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) algebraic_variables[1] = (algebraic_variables[9]+algebraic_variables[8])*(states[0]+100.0) - rates[0] = -(algebraic_variables[2]+algebraic_variables[1]+algebraic_variables[0])/constants[0] + algebraic_variables[3] = pow(states[2], 3.0)*states[1]*constants[3] + algebraic_variables[2] = (algebraic_variables[3]+0.14)*(states[0]-constants[4]) + rates[0] = (-algebraic_variables[2]-algebraic_variables[1]-algebraic_variables[0])/constants[0] algebraic_variables[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) algebraic_variables[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) rates[2] = algebraic_variables[4]*(1.0-states[2])-algebraic_variables[5]*states[2] diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index 0eae8e3112..f313de661f 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -92,8 +92,8 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - rates[1] = states[0]*1.0; - rates[0] = (constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1])*1.0; + rates[1] = states[0]; + rates[0] = constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1]; } 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 5279d4b98e..b04048c5c4 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -57,8 +57,8 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - rates[1] = states[0]*1.0 - rates[0] = (constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1])*1.0 + rates[1] = states[0] + rates[0] = constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1] def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): 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 7994670f96..fb4c76af8b 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 @@ -92,8 +92,8 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - rates[1] = states[0]*1.0; - rates[0] = (constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1])*1.0; + rates[1] = states[0]; + rates[0] = constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1]; } 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 15d560909d..ef17fe47de 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 @@ -57,8 +57,8 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - rates[1] = states[0]*1.0 - rates[0] = (constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1])*1.0 + rates[1] = states[0] + rates[0] = constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1] def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): diff --git a/tests/resources/generator/robertson_model_1966/model.dae.cellml b/tests/resources/generator/robertson_model_1966/model.dae.cellml index deeef2a61f..003117b943 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.cellml +++ b/tests/resources/generator/robertson_model_1966/model.dae.cellml @@ -8,7 +8,7 @@ • k3: 1e4 • y1: 1 • y2: 0 - • y3: 0 + • y3 Equations: • dy1/dt = -k1*y1 + k3*y2*y3 • dy2/dt = k1*y1 - k2*y2^2 - k3*y2*y3 @@ -22,7 +22,7 @@ - + diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae_linux.c similarity index 65% rename from tests/resources/generator/robertson_model_1966/model.dae.c rename to tests/resources/generator/robertson_model_1966/model.dae_linux.c index 8b78fbfa34..f6f0ec3f39 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae_linux.c @@ -83,44 +83,6 @@ 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] = 1.0-(states[1]+states[0]+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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; @@ -128,7 +90,6 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[0] = 1.0e4; constants[1] = 0.04; constants[2] = 3.0e7; - algebraicVariables[0] = 0.0; } void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) @@ -137,13 +98,13 @@ void computeComputedConstants(double voi, double *states, double *rates, double void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + algebraicVariables[0] = 1.0-states[1]-states[0]; rates[1] = -constants[1]*states[1]+constants[0]*states[0]*algebraicVariables[0]; rates[0] = constants[1]*states[1]-constants[2]*pow(states[0], 2.0)-constants[0]*states[0]*algebraicVariables[0]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + algebraicVariables[0] = 1.0-states[1]-states[0]; algebraicVariables[1] = 10000.0*states[0]; } diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae_linux.py similarity index 70% rename from tests/resources/generator/robertson_model_1966/model.dae.py rename to tests/resources/generator/robertson_model_1966/model.dae_linux.py index 9366292b74..e0957e8626 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae_linux.py @@ -50,39 +50,12 @@ 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] - - algebraic_variables[0] = u[0] - - f[0] = 1.0-(states[1]+states[0]+algebraic_variables[0]) - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[0] = u[0] - - def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 1.0 constants[0] = 1.0e4 constants[1] = 0.04 constants[2] = 3.0e7 - algebraic_variables[0] = 0.0 def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): @@ -90,11 +63,11 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + algebraic_variables[0] = 1.0-states[1]-states[0] rates[1] = -constants[1]*states[1]+constants[0]*states[0]*algebraic_variables[0] rates[0] = constants[1]*states[1]-constants[2]*pow(states[0], 2.0)-constants[0]*states[0]*algebraic_variables[0] def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + algebraic_variables[0] = 1.0-states[1]-states[0] algebraic_variables[1] = 10000.0*states[0] diff --git a/tests/resources/generator/robertson_model_1966/model.dae_macos.c b/tests/resources/generator/robertson_model_1966/model.dae_macos.c new file mode 100644 index 0000000000..388981efa3 --- /dev/null +++ b/tests/resources/generator/robertson_model_1966/model.dae_macos.c @@ -0,0 +1,110 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.dae.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 3; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "main"}; + +const VariableInfo STATE_INFO[] = { + {"y2", "dimensionless", "main"}, + {"y1", "dimensionless", "main"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"k3", "dimensionless", "main"}, + {"k1", "dimensionless", "main"}, + {"k2", "dimensionless", "main"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y3", "dimensionless", "main"}, + {"y2_scaled", "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); +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + states[1] = 1.0; + constants[0] = 1.0e4; + constants[1] = 0.04; + constants[2] = 3.0e7; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[0] = 1.0-states[0]-states[1]; + rates[1] = -constants[1]*states[1]+constants[0]*states[0]*algebraicVariables[0]; + rates[0] = constants[1]*states[1]-constants[2]*pow(states[0], 2.0)-constants[0]*states[0]*algebraicVariables[0]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[0] = 1.0-states[0]-states[1]; + algebraicVariables[1] = 10000.0*states[0]; +} diff --git a/tests/resources/generator/robertson_model_1966/model.dae_macos.py b/tests/resources/generator/robertson_model_1966/model.dae_macos.py new file mode 100644 index 0000000000..fa4b7776e6 --- /dev/null +++ b/tests/resources/generator/robertson_model_1966/model.dae_macos.py @@ -0,0 +1,73 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 2 +CONSTANT_COUNT = 3 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 2 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main"} + +STATE_INFO = [ + {"name": "y2", "units": "dimensionless", "component": "main"}, + {"name": "y1", "units": "dimensionless", "component": "main"} +] + +CONSTANT_INFO = [ + {"name": "k3", "units": "dimensionless", "component": "main"}, + {"name": "k1", "units": "dimensionless", "component": "main"}, + {"name": "k2", "units": "dimensionless", "component": "main"} +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "y3", "units": "dimensionless", "component": "main"}, + {"name": "y2_scaled", "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 + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 1.0 + constants[0] = 1.0e4 + constants[1] = 0.04 + constants[2] = 3.0e7 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[0] = 1.0-states[0]-states[1] + rates[1] = -constants[1]*states[1]+constants[0]*states[0]*algebraic_variables[0] + rates[0] = constants[1]*states[1]-constants[2]*pow(states[0], 2.0)-constants[0]*states[0]*algebraic_variables[0] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[0] = 1.0-states[0]-states[1] + algebraic_variables[1] = 10000.0*states[0] diff --git a/tests/resources/generator/robertson_model_1966/model.dae_windows.c b/tests/resources/generator/robertson_model_1966/model.dae_windows.c new file mode 100644 index 0000000000..388981efa3 --- /dev/null +++ b/tests/resources/generator/robertson_model_1966/model.dae_windows.c @@ -0,0 +1,110 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.0. */ + +#include "model.dae.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.0"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 3; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "main"}; + +const VariableInfo STATE_INFO[] = { + {"y2", "dimensionless", "main"}, + {"y1", "dimensionless", "main"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"k3", "dimensionless", "main"}, + {"k1", "dimensionless", "main"}, + {"k2", "dimensionless", "main"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y3", "dimensionless", "main"}, + {"y2_scaled", "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); +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + states[1] = 1.0; + constants[0] = 1.0e4; + constants[1] = 0.04; + constants[2] = 3.0e7; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[0] = 1.0-states[0]-states[1]; + rates[1] = -constants[1]*states[1]+constants[0]*states[0]*algebraicVariables[0]; + rates[0] = constants[1]*states[1]-constants[2]*pow(states[0], 2.0)-constants[0]*states[0]*algebraicVariables[0]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[0] = 1.0-states[0]-states[1]; + algebraicVariables[1] = 10000.0*states[0]; +} diff --git a/tests/resources/generator/robertson_model_1966/model.dae_windows.py b/tests/resources/generator/robertson_model_1966/model.dae_windows.py new file mode 100644 index 0000000000..fa4b7776e6 --- /dev/null +++ b/tests/resources/generator/robertson_model_1966/model.dae_windows.py @@ -0,0 +1,73 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.0. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.0" + +STATE_COUNT = 2 +CONSTANT_COUNT = 3 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 2 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main"} + +STATE_INFO = [ + {"name": "y2", "units": "dimensionless", "component": "main"}, + {"name": "y1", "units": "dimensionless", "component": "main"} +] + +CONSTANT_INFO = [ + {"name": "k3", "units": "dimensionless", "component": "main"}, + {"name": "k1", "units": "dimensionless", "component": "main"}, + {"name": "k2", "units": "dimensionless", "component": "main"} +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "y3", "units": "dimensionless", "component": "main"}, + {"name": "y2_scaled", "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 + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 1.0 + constants[0] = 1.0e4 + constants[1] = 0.04 + constants[2] = 3.0e7 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[0] = 1.0-states[0]-states[1] + rates[1] = -constants[1]*states[1]+constants[0]*states[0]*algebraic_variables[0] + rates[0] = constants[1]*states[1]-constants[2]*pow(states[0], 2.0)-constants[0]*states[0]*algebraic_variables[0] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[0] = 1.0-states[0]-states[1] + algebraic_variables[1] = 10000.0*states[0] diff --git a/tests/resources/generator/variable_initialised_using_another_variable/model.c b/tests/resources/generator/variable_initialised_using_another_variable/model.c index 0ab8567599..8e2da0e845 100644 --- a/tests/resources/generator/variable_initialised_using_another_variable/model.c +++ b/tests/resources/generator/variable_initialised_using_another_variable/model.c @@ -8,10 +8,10 @@ const char VERSION[] = "0.8.0"; const char LIBCELLML_VERSION[] = "0.7.0"; -const size_t STATE_COUNT = 22; +const size_t STATE_COUNT = 13; const size_t CONSTANT_COUNT = 2; -const size_t COMPUTED_CONSTANT_COUNT = 2; -const size_t ALGEBRAIC_VARIABLE_COUNT = 22; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "dimensionless", "main"}; @@ -24,55 +24,23 @@ const VariableInfo STATE_INFO[] = { {"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"} + {"xStateNla", "dimensionless", "main"} }; const VariableInfo CONSTANT_INFO[] = { {"kStateCst", "dimensionless", "main"}, - {"kNlaCst", "dimensionless", "main"} + {"kStateNla", "dimensionless", "main"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"kStateCompCst", "dimensionless", "main"}, - {"kNlaCompCst", "dimensionless", "main"} + {"kStateCompCst", "dimensionless", "main"} }; const VariableInfo ALGEBRAIC_VARIABLE_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() @@ -124,628 +92,20 @@ 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[11] = 5.0; + states[5] = states[11]; states[4] = states[5]; - algebraicVariables[16] = 7.0; - states[7] = algebraicVariables[16]; + constants[1] = 7.0; + states[7] = constants[1]; 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]; + states[10] = states[11]; + states[12] = constants[1]; } void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) @@ -754,14 +114,6 @@ void computeComputedConstants(double voi, double *states, double *rates, double 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) @@ -779,39 +131,8 @@ void computeRates(double voi, double *states, double *rates, double *constants, 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 index 8aa9c460dc..fa13b5d748 100644 --- a/tests/resources/generator/variable_initialised_using_another_variable/model.cellml +++ b/tests/resources/generator/variable_initialised_using_another_variable/model.cellml @@ -9,34 +9,10 @@ - 'xStateStateNla' as a state variable initialised using 'kStateStateNla', a state variable initialised using 'kStateNla', a non-linear algebraic variable. - Block #2: - - 'xNlaStateCst' as a non-linear algebraic variable which initial guess is provided by 'kNlaStateCst', a state variable initialised using 'kStateCst', a constant. - - 'xNlaStateCompCst' as a non-linear algebraic variable which initial guess is provided by 'kNlaStateCompCst', a state variable initialised using 'kStateCompCst', a computed constant. - - 'xNlaStateState' as a non-linear algebraic variable which initial guess is provided by 'kNlaStateState', a state variable initialised using 'kStateState', a state variable. - - 'xNlaStateNla' as a non-linear algebraic variable which initial guess is provided by 'kNlaStateNla', a state variable initialised using 'kStateNla', a non-linear algebraic variable. - - - Block #3: - - 'xStateNlaCst' as a state variable initialised using 'kStateNlaCst', a non-linear algebraic variable which initial guess is provided by 'kNlaCst', a constant. - - 'xStateNlaCompCst' as a state variable initialised using 'kStateNlaCompCst', a non-linear algebraic variable which initial guess is provided by 'kNlaCompCst', a computed constant. - - 'xStateNlaState' as a state variable initialised using 'kStateNlaState', a non-linear algebraic variable which initial guess is provided by 'kNlaState', a state variable. - - 'xStateNlaNla' as a state variable initialised using 'kStateNlaNla', a non-linear algebraic variable which initial guess is provided by 'kNlaNla', a non-linear algebraic variable. - - - Block #4: - - 'xNlaNlaCst' as a non-linear algebraic variable which initial guess is provided by 'kNlaNlaCst', a non-linear algebraic variable which initial guess is provided by 'kNlaCst', a constant. - - 'xNlaNlaCompCst' as a non-linear algebraic variable which initial guess is provided by 'kNlaNlaCompCst', a non-linear algebraic variable which initial guess is provided by 'kNlaCompCst', a computed constant. - - 'xNlaNlaState' as a non-linear algebraic variable which initial guess is provided by 'kNlaNlaState', a non-linear algebraic variable which initial guess is provided by 'kNlaState', a state variable. - - 'xNlaNlaNla' as a non-linear algebraic variable which initial guess is provided by 'kNlaNlaNla', a non-linear algebraic variable which initial guess is provided by 'kNlaNla', a non-linear algebraic variable. - - - Block #5: - 'xStateCst' as a state variable initialised using 'kStateCst', a constant. - 'xStateCompCst' as a state variable initialised using 'kStateCompCst', a computed constant. - 'xStateState' as a state variable initialised using 'kStateState', a state variable. - 'xStateNla' as a state variable initialised using 'kStateNla', a non-linear algebraic variable. - - - Block #6: - - 'xNlaCst' as a non-linear algebraic variable which initial guess is provided by 'kNlaCst', a constant. - - 'xNlaCompCst' as a non-linear algebraic variable which initial guess is provided by 'kNlaCompCst', a computed constant. - - 'xNlaState' as a non-linear algebraic variable which initial guess is provided by 'kNlaState', a state variable. - - 'xNlaNla' as a non-linear algebraic variable which initial guess is provided by 'kNlaNla', a non-linear algebraic variable. --> @@ -54,39 +30,6 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -96,17 +39,6 @@ - - - - - - - - - - - @@ -202,189 +134,6 @@ - - - - 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 - - - - - @@ -456,55 +205,5 @@ 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_another_variable/model.py b/tests/resources/generator/variable_initialised_using_another_variable/model.py index 1e4319b0fe..c9d0fef1d5 100644 --- a/tests/resources/generator/variable_initialised_using_another_variable/model.py +++ b/tests/resources/generator/variable_initialised_using_another_variable/model.py @@ -7,10 +7,10 @@ __version__ = "0.8.0" LIBCELLML_VERSION = "0.7.0" -STATE_COUNT = 22 +STATE_COUNT = 13 CONSTANT_COUNT = 2 -COMPUTED_CONSTANT_COUNT = 2 -ALGEBRAIC_VARIABLE_COUNT = 22 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main"} @@ -23,55 +23,23 @@ {"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"} + {"name": "xStateNla", "units": "dimensionless", "component": "main"} ] CONSTANT_INFO = [ {"name": "kStateCst", "units": "dimensionless", "component": "main"}, - {"name": "kNlaCst", "units": "dimensionless", "component": "main"} + {"name": "kStateNla", "units": "dimensionless", "component": "main"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "kStateCompCst", "units": "dimensionless", "component": "main"}, - {"name": "kNlaCompCst", "units": "dimensionless", "component": "main"} + {"name": "kStateCompCst", "units": "dimensionless", "component": "main"} ] ALGEBRAIC_VARIABLE_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"} ] @@ -91,552 +59,19 @@ 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] - - algebraic_variables[0] = u[0] - - f[0] = voi-algebraic_variables[0] - - -def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[0] - - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[1] = u[0] - - f[0] = voi-algebraic_variables[1] - - -def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[1] - - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[2] = u[0] - - f[0] = voi-algebraic_variables[2] - - -def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[2] - - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[3] = u[0] - - f[0] = voi-algebraic_variables[3] - - -def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[3] - - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[4] = u[0] - - f[0] = voi-algebraic_variables[4] - - -def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[4] - - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[5] = u[0] - - f[0] = voi-algebraic_variables[5] - - -def find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[5] - - u = nla_solve(objective_function_5, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[6] = u[0] - - f[0] = voi-algebraic_variables[6] - - -def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[6] - - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[7] = u[0] - - f[0] = voi-algebraic_variables[7] - - -def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[7] - - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[8] = u[0] - - f[0] = voi-algebraic_variables[8] - - -def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[8] - - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[9] = u[0] - - f[0] = voi-algebraic_variables[9] - - -def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[9] - - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[10] = u[0] - - f[0] = voi-algebraic_variables[10] - - -def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[10] - - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[11] = u[0] - - f[0] = voi-algebraic_variables[11] - - -def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[11] - - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[12] = u[0] - - f[0] = voi-algebraic_variables[12] - - -def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[12] - - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[13] = u[0] - - f[0] = voi-algebraic_variables[13] - - -def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[13] - - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[14] = u[0] - - f[0] = voi-algebraic_variables[14] - - -def find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[14] - - u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[15] = u[0] - - f[0] = voi-algebraic_variables[15] - - -def find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[15] - - u = nla_solve(objective_function_15, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[16] = u[0] - - f[0] = voi-algebraic_variables[16] - - -def find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[16] - - u = nla_solve(objective_function_16, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[17] = u[0] - - f[0] = voi-algebraic_variables[17] - - -def find_root_17(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[17] - - u = nla_solve(objective_function_17, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[18] = u[0] - - f[0] = voi-algebraic_variables[18] - - -def find_root_18(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[18] - - u = nla_solve(objective_function_18, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[19] = u[0] - - f[0] = voi-algebraic_variables[19] - - -def find_root_19(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[19] - - u = nla_solve(objective_function_19, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[20] = u[0] - - f[0] = voi-algebraic_variables[20] - - -def find_root_20(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[20] - - u = nla_solve(objective_function_20, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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] - - algebraic_variables[21] = u[0] - - f[0] = voi-algebraic_variables[21] - - -def find_root_21(voi, states, rates, constants, computed_constants, algebraic_variables): - u = [nan]*1 - - u[0] = algebraic_variables[21] - - u = nla_solve(objective_function_21, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - - algebraic_variables[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[11] = 5.0 + states[5] = states[11] states[4] = states[5] - algebraic_variables[16] = 7.0 - states[7] = algebraic_variables[16] + constants[1] = 7.0 + states[7] = constants[1] states[6] = states[7] states[8] = constants[0] - states[10] = states[19] - states[11] = algebraic_variables[16] - constants[1] = 3.0 - algebraic_variables[4] = constants[1] - states[12] = algebraic_variables[4] - states[21] = 5.0 - algebraic_variables[6] = states[21] - states[14] = algebraic_variables[6] - algebraic_variables[21] = 7.0 - algebraic_variables[7] = algebraic_variables[21] - states[15] = algebraic_variables[7] - states[16] = constants[0] - states[18] = states[19] - states[20] = algebraic_variables[16] - algebraic_variables[0] = states[8] - algebraic_variables[2] = states[10] - algebraic_variables[3] = states[11] - algebraic_variables[9] = constants[1] - algebraic_variables[8] = algebraic_variables[9] - algebraic_variables[13] = states[21] - algebraic_variables[12] = algebraic_variables[13] - algebraic_variables[15] = algebraic_variables[21] - algebraic_variables[14] = algebraic_variables[15] - algebraic_variables[17] = constants[1] - algebraic_variables[19] = states[21] - algebraic_variables[20] = algebraic_variables[21] + states[10] = states[11] + states[12] = constants[1] def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): @@ -644,14 +79,6 @@ def compute_computed_constants(voi, states, rates, constants, computed_constants states[3] = computed_constants[0] states[2] = states[3] states[9] = computed_constants[0] - computed_constants[1] = 1.23*constants[1] - algebraic_variables[5] = computed_constants[1] - states[13] = algebraic_variables[5] - states[17] = computed_constants[0] - algebraic_variables[1] = states[9] - algebraic_variables[11] = computed_constants[1] - algebraic_variables[10] = algebraic_variables[11] - algebraic_variables[18] = computed_constants[1] def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): @@ -668,37 +95,7 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v 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) + pass diff --git a/tests/test_resources.in.h b/tests/test_resources.in.h index 59479530a0..c4e53aec09 100644 --- a/tests/test_resources.in.h +++ b/tests/test_resources.in.h @@ -16,6 +16,4 @@ limitations under the License. #pragma once -#include - -const std::string TESTS_RESOURCE_LOCATION = "@TESTS_RESOURCE_LOCATION@"; +constexpr const char * const TESTS_RESOURCE_LOCATION = "@TESTS_RESOURCE_LOCATION@"; diff --git a/tests/test_utils.cpp b/tests/test_utils.cpp index 21f57ed540..6d4dddaed6 100644 --- a/tests/test_utils.cpp +++ b/tests/test_utils.cpp @@ -32,7 +32,7 @@ limitations under the License. std::string resourcePath(const std::string &resourceRelativePath) { - return TESTS_RESOURCE_LOCATION + "/" + resourceRelativePath; + return std::string(TESTS_RESOURCE_LOCATION) + "/" + resourceRelativePath; } std::string fileContents(const std::string &fileName) diff --git a/tests/test_utils.h b/tests/test_utils.h index 1199138682..0eb31dac24 100644 --- a/tests/test_utils.h +++ b/tests/test_utils.h @@ -27,6 +27,14 @@ limitations under the License. #include "../src/commonutils.h" #undef TEST_UTILS +#if defined(_WIN32) +# define OS_FILE_SUFFIX "_windows" +#elif defined(__linux__) +# define OS_FILE_SUFFIX "_linux" +#else +# define OS_FILE_SUFFIX "_macos" +#endif + const std::string EMPTY_MATH = "\n"; const std::string NON_EMPTY_MATH =