Several changes

1. Extending pycoek to setup data/param/var data with
        SequenceContext objects

2. Enable expand() logic for Parameter's

lib/coek/coek/api/expression.cpp

@@ -46,6 +46,14 @@ Parameter& Parameter::name(const std::string& name)
     return *this;
 }
 
+Parameter Parameter::expand()
+{
+#ifdef COEK_WITH_COMPACT_MODEL
+    value(this->value_expression().expand());
+#endif
+    return *this;
+}
+
 std::ostream& operator<<(std::ostream& ostr, const Parameter& arg)
 {
     write_expr(arg.repn, ostr);

lib/coek/coek/api/expression.hpp

@@ -140,6 +140,9 @@ class Parameter {
     /** \returns \c false because this is not a contant */
     bool is_constant() const { return false; }
 
+    /** \returns an expanded Parameter */
+    Parameter expand();
+
     /**
      * \name Stream operator
      *

lib/coek/coek/compact/parameter_map.cpp

@@ -1,5 +1,6 @@
 #include <unordered_map>
 
+#include "coek/util/io_utils.hpp"
 #include "coek/ast/compact_terms.hpp"
 #include "coek/api/parameter_assoc_array_repn.hpp"
 #include "coek/compact/coek_sets.hpp"
@@ -27,7 +28,6 @@ class ParameterMapRepn : public ParameterAssocArrayRepn {
 #endif
     }
 
-    // ParameterMapRepn(const SequenceContext& _arg) : concrete_set(_arg.index_set())
     ParameterMapRepn(const SequenceContext& _arg) : context(_arg), index_sequence(context)
     {
         index_set = context.index_set();
@@ -92,8 +92,8 @@ void ParameterMapRepn::generate_names()
 void ParameterMapRepn::expand()
 {
     if (first_expand) {
+        // std::cout << "HERE - Expanding " << value_template.name() << std::endl;
         first_expand = false;
-        // ParameterAssocArrayRepn::expand();
 
         size_t _dim = dim();
         IndexVector x(_dim);

lib/coek/coek/compact/visitor_exprtemplate.cpp

@@ -30,7 +30,8 @@ expr_pointer_t visit_IndexParameterTerm(const expr_pointer_t& expr)
     else
         throw std::runtime_error(
             "Unexpected index parameter in an expression being converted, with a non-numeric "
-            "value.");
+            "value: "
+            + tmp->name);
 }
 
 expr_pointer_t visit_VariableRefTerm(const expr_pointer_t& expr)

lib/coek/coek/model/compact_model.cpp

@@ -257,8 +257,7 @@ Model CompactModel::expand()
         if (auto eval = std::get_if<Parameter>(&val)) {
             // NOTE: Are we expanding this data in place?  Do we need to create a copy
             //      of this parameter within all expressions?
-            Expression value = eval->value_expression().expand();
-            eval->value(value.value());
+            eval->expand();
             // model.add_parameter(*eval);
         }
         else
@@ -287,15 +286,16 @@ Model CompactModel::expand()
         }
     }
 
+    // std::cout << "Expanding parameters " << repn->parameters.size() << std::endl;
     for (auto& val : repn->parameters) {
         if (auto eval = std::get_if<Parameter>(&val)) {
-            // NOTE: Are we expanding this parameter in place?  Do we need to create a copy
-            //      of this parameter within all expressions?
-            Expression value = eval->value_expression().expand();
-            eval->value(value.value());
-            // model.add_parameter(*eval);
+            // std::cout << "Parameter " << eval->name() << std::endl;
+            //  NOTE: We are expanding this parameter in place so we do not need to create a copy
+            //       of this parameter within all expressions
+            eval->expand();
         }
         else if (auto eval = std::get_if<ParameterMap>(&val)) {
+            // std::cout << "HERE x" << std::endl;
             eval->expand();
             for (auto param : *eval) {
                 // NOTE: Are we changing the values of these maps in place?
@@ -305,6 +305,7 @@ Model CompactModel::expand()
             model.repn->parameter_maps.push_back(*eval);
         }
         else if (auto eval = std::get_if<ParameterArray>(&val)) {
+            // std::cout << "HERE y" << std::endl;
             eval->expand();
             for (auto param : *eval) {
                 // NOTE: Are we changing the values of these maps in place?

lib/pycoek/pybind11/pycoek_pybind11.cpp

@@ -293,18 +293,46 @@ py::list to_nested_list(std::list<std::string>::iterator& it, std::list<std::str
     return tmp;
 }
 
-template <typename TYPE>
-void parse_varargs(py::kwargs kwargs, const char* name, TYPE& lb, TYPE _default)
+bool parse_varargs(py::kwargs kwargs, const char* name, bool _default)
 {
-    lb = _default;
+    bool ans(_default);
     try {
-        auto _lb = kwargs[name];
-        if (_lb.is_none())
-            return;
-        lb = _lb.cast<TYPE>();
+        auto _val = kwargs[name];
+        if (_val.is_none())
+            return ans;
+        try {
+            ans = _val.cast<double>();
+        }
+        catch (std::exception& err) {
+        }
+    }
+    catch (std::exception& err) {
+    }
+    return ans;
+}
+
+coek::Expression parse_varargs(py::kwargs kwargs, const char* name, double _default)
+{
+    coek::Expression ans(_default);
+    try {
+        auto _val = kwargs[name];
+        if (_val.is_none())
+            return ans;
+        try {
+            double val = _val.cast<double>();
+            return coek::Expression(val);
+        }
+        catch (std::exception& err) {
+        }
+        try {
+            return _val.cast<Expression>();
+        }
+        catch (std::exception& err) {
+        }
     }
     catch (std::exception& err) {
     }
+    return ans;
 }
 
 class VecKeyIterator {
@@ -509,14 +537,12 @@ VariableArray* variable_fn(int n, py::kwargs kwargs)
 template <class TYPE>
 void set_kwargs(TYPE& var, py::kwargs kwargs)
 {
-    double lb, ub, value;
-    bool binary, integer, fixed;
-    parse_varargs<double>(kwargs, "lb", lb, -COEK_INFINITY);
-    parse_varargs<double>(kwargs, "ub", ub, COEK_INFINITY);
-    parse_varargs<double>(kwargs, "value", value, NAN);
-    parse_varargs<bool>(kwargs, "binary", binary, false);
-    parse_varargs<bool>(kwargs, "integer", integer, false);
-    parse_varargs<bool>(kwargs, "fixed", fixed, false);
+    auto lb = parse_varargs(kwargs, "lb", -COEK_INFINITY);
+    auto ub = parse_varargs(kwargs, "ub", COEK_INFINITY);
+    auto value = parse_varargs(kwargs, "value", NAN);
+    auto binary = parse_varargs(kwargs, "binary", false);
+    auto integer = parse_varargs(kwargs, "integer", false);
+    auto fixed = parse_varargs(kwargs, "fixed", false);
 
     try {
         var.value(value).bounds(lb, ub).fixed(fixed);
@@ -542,8 +568,7 @@ void set_kwargs(TYPE& var, py::kwargs kwargs)
 template <class TYPE>
 void set_param_kwargs(TYPE& param, py::kwargs kwargs)
 {
-    double value;
-    parse_varargs<double>(kwargs, "value", value, NAN);
+    auto value = parse_varargs(kwargs, "value", NAN);
 
     try {
         param.value(value);
@@ -566,13 +591,11 @@ void set_param_kwargs(TYPE& param, py::kwargs kwargs)
 template <class TYPE>
 void set_kwargs_varmap(TYPE& var, py::kwargs kwargs)
 {
-    double lb, ub, value;
-    bool binary, integer;
-    parse_varargs<double>(kwargs, "lb", lb, -COEK_INFINITY);
-    parse_varargs<double>(kwargs, "ub", ub, COEK_INFINITY);
-    parse_varargs<double>(kwargs, "value", value, NAN);
-    parse_varargs<bool>(kwargs, "binary", binary, false);
-    parse_varargs<bool>(kwargs, "integer", integer, false);
+    auto lb = parse_varargs(kwargs, "lb", -COEK_INFINITY);
+    auto ub = parse_varargs(kwargs, "ub", COEK_INFINITY);
+    auto value = parse_varargs(kwargs, "value", NAN);
+    auto binary = parse_varargs(kwargs, "binary", false);
+    auto integer = parse_varargs(kwargs, "integer", false);
     // parse_varargs<bool>(kwargs, "fixed", fixed, false);
 
     try {
@@ -603,11 +626,17 @@ VariableMap variable_fn(coek::ConcreteSet& index_set, py::kwargs kwargs)
     return tmp;
 }
 
+VariableMap variable_fn(coek::SequenceContext& context, py::kwargs kwargs)
+{
+    VariableMap tmp(context);
+    set_kwargs_varmap(tmp, kwargs);
+    return tmp;
+}
+
 template <class TYPE>
 void set_kwargs_parammap(TYPE& param, py::kwargs kwargs)
 {
-    double value;
-    parse_varargs<double>(kwargs, "value", value, NAN);
+    auto value = parse_varargs(kwargs, "value", NAN);
 
     try {
         param.value(value);
@@ -633,12 +662,26 @@ ParameterMap parameter_fn(coek::ConcreteSet& index_set, py::kwargs kwargs)
     return tmp;
 }
 
+ParameterMap parameter_fn(coek::SequenceContext& context, py::kwargs kwargs)
+{
+    ParameterMap tmp(context);
+    set_kwargs_parammap(tmp, kwargs);
+    return tmp;
+}
+
 DataMap data_fn(coek::ConcreteSet& index_set, py::kwargs kwargs)
 {
     DataMap tmp(index_set);
     set_kwargs_parammap(tmp, kwargs);
     return tmp;
 }
+
+DataMap data_fn(coek::SequenceContext& context, py::kwargs kwargs)
+{
+    DataMap tmp(context);
+    set_kwargs_parammap(tmp, kwargs);
+    return tmp;
+}
 #endif
 
 VariableArray variable_fn(std::vector<int>& dimen, py::kwargs kwargs)
@@ -874,11 +917,19 @@ PYBIND11_MODULE(pycoek_pybind11, m)
     m.def("variable_", [](coek::ConcreteSet& index_set, py::kwargs kw) {
         return coek::variable_fn(index_set, kw);
     });
+    m.def("variable_", [](coek::SequenceContext& context, py::kwargs kw) {
+        return coek::variable_fn(context, kw);
+    });
+    m.def("parameter_", [](coek::SequenceContext& contxt, py::kwargs kw) {
+        return coek::parameter_fn(contxt, kw);
+    });
     m.def("parameter_", [](coek::ConcreteSet& index_set, py::kwargs kw) {
         return coek::parameter_fn(index_set, kw);
     });
     m.def("data_",
           [](coek::ConcreteSet& index_set, py::kwargs kw) { return coek::data_fn(index_set, kw); });
+    m.def("data_",
+          [](coek::SequenceContext& context, py::kwargs kw) { return coek::data_fn(context, kw); });
 #endif
     m.def("affine_expression", [](std::vector<double>& coef, std::vector<coek::Variable>& var,
                                   double offset) { return affine_expression(coef, var, offset); });