Interpreter: allocate the different arrays.

src/api/libcellml/interpreter.h

@@ -19,6 +19,8 @@ limitations under the License.
 #include "libcellml/exportdefinitions.h"
 #include "libcellml/types.h"
 
+#include <vector>
+
 namespace libcellml {
 
 /**
@@ -75,59 +77,32 @@ class LIBCELLML_EXPORT Interpreter
      */
     double voi();
 
-    /**
-     * @brief Get the number of states in the model.
-     *
-     * Return the number of states in the model. If the model doesn't have any states then 0 is returned.
-     *
-     * @return The number of states in the model as a @c size_t.
-     */
-    size_t stateCount();
-
     /**
      * @brief Get the model's states.
      *
      * Return the model's states. If the model doesn't have any states then @c nullptr is returned.
      *
-     * @return The model's states as an array of @c double.
-     */
-    double *states();
-
-    /**
-     * @brief Get the number of rates in the model.
-     *
-     * Return the number of rates in the model. If the model doesn't have any rates then 0 is returned.
-     *
-     * @return The number of rates in the model as a @c size_t.
+     * @return The model's states as a @c std::vector of @c double.
      */
-    size_t rateCount();
+    std::vector<double> states();
 
     /**
      * @brief Get the model's rates.
      *
      * Return the model's rates. If the model doesn't have any rates then @c nullptr is returned.
      *
-     * @return The model's rates as an array of @c double.
-     */
-    double *rates();
-
-    /**
-     * @brief Get the number of variables in the model.
-     *
-     * Return the number of variables in the model. If the model doesn't have any variables then 0 is returned.
-     *
-     * @return The number of variables in the model as a @c size_t.
+     * @return The model's rates as a @c std::vector of @c double.
      */
-    size_t variableCount();
+    std::vector<double> rates();
 
     /**
      * @brief Get the model's variables.
      *
      * Return the model's variables.
      *
-     * @return The model's variables as an array of @c double.
+     * @return The model's variables as a @c std::vector of @c double.
      */
-    double *variables();
+    std::vector<double> variables();
 
     /**
      * @brief Initialise the model's variables.

src/bindings/interface/interpreter.i

@@ -3,6 +3,7 @@
 #define LIBCELLML_EXPORT
 
 %include <std_string.i>
+%include <std_vector.i>
 
 %import "analysermodel.i"
 %import "createconstructor.i"
@@ -19,21 +20,12 @@
 %feature("docstring") libcellml::Interpreter::voi
 "Returns the value of the model's variable of integration.";
 
-%feature("docstring") libcellml::Interpreter::stateCount
-"Returns the number of states in the model.";
-
 %feature("docstring") libcellml::Interpreter::states
 "Returns the model's states.";
 
-%feature("docstring") libcellml::Interpreter::rateCount
-"Returns the number of rates in the model.";
-
 %feature("docstring") libcellml::Interpreter::rates
 "Returns the model's rates.";
 
-%feature("docstring") libcellml::Interpreter::variableCount
-"Returns the number of variables in the model.";
-
 %feature("docstring") libcellml::Interpreter::variables
 "Returns the model's variables.";
 
@@ -53,6 +45,8 @@
 #include "libcellml/interpreter.h"
 %}
 
+%template(DoubleVector) std::vector<double>;
+
 %pythoncode %{
 # libCellML generated wrapper code starts here.
 %}

src/bindings/javascript/interpreter.cpp

@@ -27,39 +27,9 @@ EMSCRIPTEN_BINDINGS(libcellml_interpreter)
         .function("model", &libcellml::Interpreter::model)
         .function("setModel", &libcellml::Interpreter::setModel)
         .function("voi", &libcellml::Interpreter::voi)
-        .function("stateCount", &libcellml::Interpreter::stateCount)
-        .function("states", emscripten::optional_override([](libcellml::InterpreterPtr &interpreter) {
-                      auto states = interpreter->states();
-                      auto stateCount = interpreter->stateCount();
-                      auto view = emscripten::typed_memory_view(stateCount, states);
-                      auto res = emscripten::val::global("Uint8Array").new_(stateCount);
-
-                      res.call<void>("set", view);
-
-                      return res;
-                  }))
-        .function("rateCount", &libcellml::Interpreter::rateCount)
-        .function("rates", emscripten::optional_override([](libcellml::InterpreterPtr &interpreter) {
-                      auto rates = interpreter->rates();
-                      auto rateCount = interpreter->rateCount();
-                      auto view = emscripten::typed_memory_view(rateCount, rates);
-                      auto res = emscripten::val::global("Uint8Array").new_(rateCount);
-
-                      res.call<void>("set", view);
-
-                      return res;
-                  }))
-        .function("variableCount", &libcellml::Interpreter::variableCount)
-        .function("variables", emscripten::optional_override([](libcellml::InterpreterPtr &interpreter) {
-                      auto variables = interpreter->variables();
-                      auto variableCount = interpreter->variableCount();
-                      auto view = emscripten::typed_memory_view(variableCount, variables);
-                      auto res = emscripten::val::global("Uint8Array").new_(variableCount);
-
-                      res.call<void>("set", view);
-
-                      return res;
-                  }))
+        .function("states", &libcellml::Interpreter::states)
+        .function("rates", &libcellml::Interpreter::rates)
+        .function("variables", &libcellml::Interpreter::variables)
         .function("initialiseVariables", &libcellml::Interpreter::initialiseVariables)
         .function("computeComputedConstants", &libcellml::Interpreter::computeComputedConstants)
         .function("computeRates", &libcellml::Interpreter::computeRates)

src/bindings/javascript/types.cpp

@@ -22,6 +22,7 @@ using namespace emscripten;
 
 EMSCRIPTEN_BINDINGS(libcellml_types)
 {
+    register_vector<double>("VectorDouble");
     register_vector<std::string>("VectorString");
     register_vector<libcellml::AnyCellmlElementPtr>("VectorAnyCellmlElementPtr");
     register_vector<libcellml::VariablePtr>("VectorVariablePtr");

src/interpreter.cpp

@@ -16,10 +16,31 @@ limitations under the License.
 
 #include "libcellml/interpreter.h"
 
+#include "libcellml/analysermodel.h"
+
 #include "interpreter_p.h"
 
 namespace libcellml {
 
+void Interpreter::InterpreterImpl::setModel(const AnalyserModelPtr &model)
+{
+    mModel = model;
+
+    if (mModel != nullptr) {
+        mStates.resize(mModel->stateCount());
+        mRates.resize(mModel->stateCount());
+        mVariables.resize(mModel->variableCount());
+
+        mVoi = 0.0;
+
+        static const auto NaN = std::numeric_limits<double>::quiet_NaN();
+
+        std::fill(mStates.begin(), mStates.end(), NaN);
+        std::fill(mRates.begin(), mRates.end(), NaN);
+        std::fill(mVariables.begin(), mVariables.end(), NaN);
+    }
+}
+
 Interpreter::Interpreter()
     : mPimpl(new InterpreterImpl())
 {
@@ -42,40 +63,25 @@ AnalyserModelPtr Interpreter::model()
 
 void Interpreter::setModel(const AnalyserModelPtr &model)
 {
-    mPimpl->mModel = model;
+    mPimpl->setModel(model);
 }
 
 double Interpreter::voi()
 {
     return mPimpl->mVoi;
 }
 
-size_t Interpreter::stateCount()
-{
-    return mPimpl->mStateCount;
-}
-
-double *Interpreter::states()
+std::vector<double> Interpreter::states()
 {
     return mPimpl->mStates;
 }
 
-size_t Interpreter::rateCount()
-{
-    return mPimpl->mRateCount;
-}
-
-double *Interpreter::rates()
+std::vector<double> Interpreter::rates()
 {
     return mPimpl->mRates;
 }
 
-size_t Interpreter::variableCount()
-{
-    return mPimpl->mVariableCount;
-}
-
-double *Interpreter::variables()
+std::vector<double> Interpreter::variables()
 {
     return mPimpl->mVariables;
 }

src/interpreter_p.h

@@ -32,15 +32,11 @@ struct Interpreter::InterpreterImpl
     AnalyserModelPtr mModel;
 
     double mVoi = 0.0;
+    std::vector<double> mStates;
+    std::vector<double> mRates;
+    std::vector<double> mVariables;
 
-    size_t mStateCount = 0;
-    double *mStates = nullptr;
-
-    size_t mRateCount = 0;
-    double *mRates = nullptr;
-
-    size_t mVariableCount = 0;
-    double *mVariables = nullptr;
+    void setModel(const AnalyserModelPtr &model);
 };
 
 } // namespace libcellml

tests/bindings/javascript/interpreter.test.js

@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 const loadLibCellML = require('libcellml.js/libcellml.common')
-const { basicModel } = require('./resources')
+const { hhSquidAxon1952 } = require('./resources')
 
 let libcellml = null
 
@@ -27,7 +27,7 @@ describe("Interpreter tests", () => {
         const i = new libcellml.Interpreter()
         const p = new libcellml.Parser(true)
 
-        m = p.parseModel(basicModel)
+        m = p.parseModel(hhSquidAxon1952)
         a = new libcellml.Analyser()
 
         a.analyseModel(m)
@@ -40,14 +40,9 @@ describe("Interpreter tests", () => {
 
         expect(i.voi()).toBe(0.0)
 
-        expect(i.stateCount()).toBe(0)
-        expect(i.states()).toHaveLength(0)
-
-        expect(i.rateCount()).toBe(0)
-        expect(i.rates()).toHaveLength(0)
-
-        expect(i.variableCount()).toBe(0)
-        expect(i.variables()).toHaveLength(0)
+        expect(i.states().size()).toBe(4)
+        expect(i.rates().size()).toBe(4)
+        expect(i.variables().size()).toBe(18)
 
         i.initialiseVariables()
         i.computeComputedConstants()

tests/bindings/python/test_interpreter.py

@@ -12,22 +12,22 @@ def test_create_destroy(self):
         x = Interpreter()
         del x
 
-    def test_algebraic_eqn_computed_var_on_rhs(self):
+    def test_hodgkin_huxley_squid_axon_model_1952(self):
         from libcellml import Analyser
         from libcellml import AnalyserModel
         from libcellml import Interpreter
         from libcellml import Parser
         from test_resources import file_contents
 
         p = Parser()
-        m = p.parseModel(file_contents('generator/algebraic_eqn_computed_var_on_rhs/model.cellml'))
-
+        m = p.parseModel(file_contents('generator/hodgkin_huxley_squid_axon_model_1952/model.cellml'))
         a = Analyser()
+
         a.analyseModel(m)
 
         am = a.model()
 
-        self.assertEqual(AnalyserModel.Type.ALGEBRAIC, am.type())
+        self.assertEqual(AnalyserModel.Type.ODE, am.type())
 
         i = Interpreter()
 
@@ -39,14 +39,9 @@ def test_algebraic_eqn_computed_var_on_rhs(self):
 
         self.assertEqual(0.0, i.voi())
 
-        self.assertEqual(0, i.stateCount())
-        self.assertIsNone(i.states())
-
-        self.assertEqual(0, i.rateCount())
-        self.assertIsNone(i.rates())
-
-        self.assertEqual(0, i.variableCount())
-        self.assertIsNone(i.variables())
+        self.assertEqual(4, len(i.states()))
+        self.assertEqual(4, len(i.rates()))
+        self.assertEqual(18, len(i.variables()))
 
         i.initialiseVariables()
         i.computeComputedConstants()

tests/generator/generator.cpp

@@ -45,14 +45,9 @@ TEST(Generator, emptyModel)
 
     EXPECT_EQ(0.0, interpreter->voi());
 
-    EXPECT_EQ(size_t(0), interpreter->stateCount());
-    EXPECT_EQ(nullptr, interpreter->states());
-
-    EXPECT_EQ(size_t(0), interpreter->rateCount());
-    EXPECT_EQ(nullptr, interpreter->rates());
-
-    EXPECT_EQ(size_t(0), interpreter->variableCount());
-    EXPECT_EQ(nullptr, interpreter->variables());
+    EXPECT_EQ(size_t(0), interpreter->states().size());
+    EXPECT_EQ(size_t(0), interpreter->rates().size());
+    EXPECT_EQ(size_t(0), interpreter->variables().size());
 }
 
 TEST(Generator, algebraicEqnComputedVarOnRhs)