Dummy UEncConstraint #232

include/mp/flat/constr_general.h

@@ -79,6 +79,13 @@ using IndicatorConstraintQuadEQ = IndicatorConstraint<QuadConEQ>;
 using IndicatorConstraintQuadGE = IndicatorConstraint<QuadConGE>;
 
 
+/// Unary encoding.
+/// Currently a dummy constraint just to build
+/// the reformulation graph.
+DEF_STATIC_CONSTR(UnaryEncodingConstraint, VarArray1,
+                  "Unary encoding of an integer bounded variable");
+
+
 ////////////////////////////////////////////////////////////////////////
 /// SOS1, SOS2
 
@@ -277,17 +284,17 @@ DEF_STATIC_CONSTR_WITH_PRM( QuadraticConeConstraint, VarArray, DblParamArray,
 DEF_STATIC_CONSTR_WITH_PRM( RotatedQuadraticConeConstraint, VarArray, DblParamArray,
                             "Rotated quadratic cone "
                             "2 * p1*x1*p2*x2 >= (p3*x3)^2 + ...),"
-                            " x1, x2 >= 0, with factors p1..pn");
+                            " x1, x2 >= 0 or x1, x2 <= 0, with factors p1..pn");
 /// Exponential cone
 DEF_STATIC_CONSTR_WITH_PRM( ExponentialConeConstraint, VarArray3, DblParamArray3,
                             "Exponential cone ax >= by exp(cz / (by)),"
                             " where ax, by >= 0, with factors a,b,c");
 /// Power cone
 DEF_STATIC_CONSTR_WITH_PRM( PowerConeConstraint, VarArray, DblParamArray,
-                            "Power cone with factors ");
+                            "Power cone with factors");
 /// Geometric cone
 DEF_STATIC_CONSTR_WITH_PRM( GeometricConeConstraint, VarArray, DblParamArray,
-                            "Geometric with factors ");
+                            "Geometric with factors");
 
 } // namespace mp
 

include/mp/flat/converter.h

@@ -1242,6 +1242,8 @@ class FlatConverter :
   pre::NodeRange auto_link_src_item_;   // the source item for autolinking
   std::vector<pre::NodeRange> auto_link_targ_items_;
 
+  pre::Many2OneLink many2one_link_ { GetValuePresolver() }; // the many-to-one links
+
 	ConicConverter<Impl> conic_cvt_ { *static_cast<Impl*>(this) };
   int nQC2SOCPAttempted_= 0;
   int nQC2SOCPSucceeded_= 0;
@@ -1367,6 +1369,11 @@ class FlatConverter :
       ExponentialConeConstraint, "acc:expcone")
   STORE_CONSTRAINT_TYPE__NO_MAP(
       GeometricConeConstraint, "acc:geomcone")
+  /// Store UEncConstr
+  STORE_CONSTRAINT_TYPE__NO_MAP(
+      UnaryEncodingConstraint, "acc:uenc")
+  /// Dummy conversion for UEncConstr
+  void Convert(const UnaryEncodingConstraint& ) { }
 
 
 	protected:
@@ -1437,6 +1444,9 @@ class FlatConverter :
 
   /// ValuePresolve link copying values 1:many
   pre::One2ManyLink& GetOne2ManyLink() { return one2many_link_; }
+
+  /// ValuePresolve link copying values many:1
+  pre::Many2OneLink& GetMany2OneLink() { return many2one_link_; }
 };
 
 

include/mp/flat/redef/MIP/cond_eq.h

@@ -43,7 +43,7 @@ class CondEQConverter_MIP :
         !GetMC().IfMightUseEqualityEncodingForVar(
           args.var(0))) {
       Base::Convert(eq0c, i); // Calls ConvertCtxPos / Neg
-    } // else, using unary encoding whose flags are,
+    } // else, might use unary encoding whose flags are,
   }   // in the fixed case, fixed by PropagateResult()
 
   /// Convert in positive context

include/mp/flat/redef/MIP/converter_mip.h

@@ -190,7 +190,7 @@ class MIPFlatConverter
     const auto ub_dbl = this->ub(var);
     return (lb_dbl>std::numeric_limits<int>::min() &&
             ub_dbl<std::numeric_limits<int>::max()) &&
-        (ub_dbl-lb_dbl <= 100000);
+        (ub_dbl-lb_dbl <= 10000000);
   }
 
   /// Obtain extended column \a k of ZZI encoding C^r
@@ -214,6 +214,8 @@ class MIPFlatConverter
 
 
 protected:
+  /// Return index of CondLinEQ for this \a val,
+  /// if saved before
   int MapFind__VarConstCmp(int var, double val) {
     auto itVar = map_vars_eq_const_.find(var);
     if (map_vars_eq_const_.end() != itVar) {
@@ -302,7 +304,15 @@ class MIPFlatConverter
     CreateUnaryEncoding(var, map);
   }
 
+  /// Create unary encoding once we go for it.
+  /// Adds a dummy UnaryEncodingConstraint for graph linking.
+  /// Another design would be to have an "EqualityEncodingConstraint"
+  /// and move all conversions there (indicators vs unary encoding.)
+  /// That would partially automate linking.
+  /// A benefit would be if some solver later supports them natively
+  /// (IloDistribute?), now they are always converted below.
   void CreateUnaryEncoding(int var, const SingleVarEqConstMap& map) {
+    auto valnode = MPD( AddConstraint( UnaryEncodingConstraint{{var}} ) );
     const Model& model = MP_DISPATCH( GetModel() );
     if (!model.is_integer_var(var))
       MP_RAISE("MP2MIP: Equality encoding: comparing non-integer variables not implemented");