Analysis: fix bugs
[scilab.git] / scilab / modules / ast / src / cpp / analysis / InferenceConstraints.cpp
index 6909c6d..bd01aaf 100644 (file)
 
 namespace analysis
 {
-    InferenceConstraint::Result SameDimsConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
-    {
-        const GVN::Value & R1 = *values[0];
-        const GVN::Value & C1 = *values[1];
-        const GVN::Value & R2 = *values[2];
-        const GVN::Value & C2 = *values[3];
+InferenceConstraint::Result SameDimsConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+{
+    const GVN::Value & R1 = *values[0];
+    const GVN::Value & C1 = *values[1];
+    const GVN::Value & R2 = *values[2];
+    const GVN::Value & C2 = *values[3];
 
-        if (R1.value == R2.value)
+    if (R1.value == R2.value)
+    {
+        if (C1.value == C2.value)
         {
-            if (C1.value == C2.value)
-            {
-                return Result::RESULT_TRUE;
-            }
+            return Result::RESULT_TRUE;
+        }
 
-            MultivariatePolynomial mp = *C1.poly - *C2.poly;
-            if (mp.constant != 0 && mp.isCoeffPositive(false))
-            {
-                return Result::RESULT_FALSE;
-            }
+        MultivariatePolynomial mp = *C1.poly - *C2.poly;
+        if (mp.constant != 0 && mp.isCoeffPositive(false))
+        {
+            return Result::RESULT_FALSE;
         }
-        else
+    }
+    else
+    {
+        MultivariatePolynomial mp = *R1.poly - *R2.poly;
+        if (mp.constant > 0 && mp.isCoeffPositive(false))
         {
-            MultivariatePolynomial mp = *R1.poly - *R2.poly;
-            if (mp.constant > 0 && mp.isCoeffPositive(false))
-            {
-                return Result::RESULT_FALSE;
-            }
+            return Result::RESULT_FALSE;
         }
-        return Result::RESULT_DUNNO;
     }
+    return Result::RESULT_DUNNO;
+}
 
-    MPolyConstraintSet SameDimsConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
-    {
-        MPolyConstraintSet set(2);
-        const GVN::Value & R1 = *values[0];
-        const GVN::Value & C1 = *values[1];
-        const GVN::Value & R2 = *values[2];
-        const GVN::Value & C2 = *values[3];
+MPolyConstraintSet SameDimsConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
+{
+    MPolyConstraintSet set(2);
+    const GVN::Value & R1 = *values[0];
+    const GVN::Value & C1 = *values[1];
+    const GVN::Value & R2 = *values[2];
+    const GVN::Value & C2 = *values[3];
 
-        set.add(*R1.poly - *R2.poly, MPolyConstraint::Kind::EQ0);
-        set.add(*C1.poly - *C2.poly, MPolyConstraint::Kind::EQ0);
+    set.add(*R1.poly - *R2.poly, MPolyConstraint::Kind::EQ0);
+    set.add(*C1.poly - *C2.poly, MPolyConstraint::Kind::EQ0);
 
-        return set;
-    }
+    return set;
+}
 
-    void SameDimsConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const
-    {
-        GVN::Value & R1 = *values[0];
-        GVN::Value & C1 = *values[1];
-        GVN::Value & R2 = *values[2];
-        GVN::Value & C2 = *values[3];
+void SameDimsConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const
+{
+    GVN::Value & R1 = *values[0];
+    GVN::Value & C1 = *values[1];
+    GVN::Value & R2 = *values[2];
+    GVN::Value & C2 = *values[3];
 
-        applyEquality(R1, R2);
-        applyEquality(C1, C2);
-    }
+    applyEquality(R1, R2);
+    applyEquality(C1, C2);
+}
 
-    InferenceConstraint::Result EqualConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
-    {
-        const GVN::Value & x = *values[0];
-        const GVN::Value & y = *values[1];
+InferenceConstraint::Result EqualConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+{
+    const GVN::Value & x = *values[0];
+    const GVN::Value & y = *values[1];
 
-        if (x.value == y.value)
-        {
-            return Result::RESULT_TRUE;
-        }
-        else
+    if (x.value == y.value)
+    {
+        return Result::RESULT_TRUE;
+    }
+    else
+    {
+        MultivariatePolynomial mp = *x.poly - *y.poly;
+        if (mp.constant > 0 && mp.isCoeffPositive(false))
         {
-            MultivariatePolynomial mp = *x.poly - *y.poly;
-            if (mp.constant > 0 && mp.isCoeffPositive(false))
-            {
-                return Result::RESULT_FALSE;
-            }
+            return Result::RESULT_FALSE;
         }
-        return Result::RESULT_DUNNO;
     }
+    return Result::RESULT_DUNNO;
+}
 
-    void EqualConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const
-    {
-        GVN::Value & x = *values[0];
-        GVN::Value & y = *values[1];
+void EqualConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const
+{
+    GVN::Value & x = *values[0];
+    GVN::Value & y = *values[1];
 
-        applyEquality(x, y);
-    }
+    applyEquality(x, y);
+}
 
-    MPolyConstraintSet EqualConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
-    {
-        MPolyConstraintSet set(1);
-        const GVN::Value & x = *values[0];
-        const GVN::Value & y = *values[1];
+MPolyConstraintSet EqualConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
+{
+    MPolyConstraintSet set(1);
+    const GVN::Value & x = *values[0];
+    const GVN::Value & y = *values[1];
 
-        set.add(*x.poly - *y.poly, MPolyConstraint::Kind::EQ0);
+    set.add(*x.poly - *y.poly, MPolyConstraint::Kind::EQ0);
 
-        return set;
-    }
+    return set;
+}
 
-    InferenceConstraint::Result MPolyConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
-    {
-        const std::vector<const MultivariatePolynomial *> & args = InferenceConstraint::getArgs(values);
-        MultivariatePolynomial mp;// = poly.eval();
+InferenceConstraint::Result MPolyConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+{
+    const std::vector<const MultivariatePolynomial *> & args = InferenceConstraint::getArgs(values);
+    MultivariatePolynomial mp;
 
-        if (poly.containsVarsGEq(args.size()))
-        {
-            mp = poly.eval(args);
-        }
-        else
-        {
-            mp = poly.translateVariables(gvn.getCurrentValue() + 1, args.size()).eval(args);
-        }
+    if (poly.containsVarsGEq(args.size()))
+    {
+        mp = poly.translateVariables(gvn.getCurrentValue() + 1, args.size()).eval(args);
+    }
+    else
+    {
+        mp = poly.eval(args);
+    }
 
-        switch (kind)
-        {
+    switch (kind)
+    {
         case EQ0:
         {
             if (mp.isConstant(0))
@@ -183,279 +183,279 @@ namespace analysis
                 return Result::RESULT_DUNNO;
             }
         }
-        }
     }
+}
 
-    MPolyConstraintSet MPolyConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
-    {
-        MPolyConstraintSet set(1);
-        set.add(poly.eval(InferenceConstraint::getArgs(values)), kind);
+MPolyConstraintSet MPolyConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
+{
+    MPolyConstraintSet set(1);
+    set.add(poly.eval(InferenceConstraint::getArgs(values)), kind);
 
-        return set;
-    }
+    return set;
+}
 
-    void MPolyConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const
+void MPolyConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const
+{
+    if (kind == EQ0)
     {
-        if (kind == EQ0)
+        if (poly.constant == 0 && poly.polynomial.size() == 2)
         {
-            if (poly.constant == 0 && poly.polynomial.size() == 2)
-            {
-                const MultivariateMonomial & m1 = *poly.polynomial.begin();
-                const MultivariateMonomial & m2 = *std::next(poly.polynomial.begin());
+            const MultivariateMonomial & m1 = *poly.polynomial.begin();
+            const MultivariateMonomial & m2 = *std::next(poly.polynomial.begin());
 
-                if (((m1.coeff == 1 && m2.coeff == -1) || (m1.coeff == -1 && m2.coeff == 1)) && (m1.monomial.size() == 1 && m2.monomial.size() == 1))
-                {
-                    // We have a polynomial P such as P(X,Y)=X-Y
-                    GVN::Value & x = *values[m1.monomial.begin()->var];
-                    GVN::Value & y = *values[m2.monomial.begin()->var];
+            if (((m1.coeff == 1 && m2.coeff == -1) || (m1.coeff == -1 && m2.coeff == 1)) && (m1.monomial.size() == 1 && m2.monomial.size() == 1))
+            {
+                // We have a polynomial P such as P(X,Y)=X-Y
+                GVN::Value & x = *values[m1.monomial.begin()->var];
+                GVN::Value & y = *values[m2.monomial.begin()->var];
 
-                    applyEquality(x, y);
-                }
+                applyEquality(x, y);
             }
         }
     }
+}
 
-    InferenceConstraint::Result MPolyConstraintSet::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+InferenceConstraint::Result MPolyConstraintSet::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+{
+    for (const auto & constraint : constraints)
     {
-        for (const auto & constraint : constraints)
+        Result res = constraint.check(gvn, values);
+        if (res != Result::RESULT_TRUE)
         {
-            Result res = constraint.check(gvn, values);
-            if (res != Result::RESULT_TRUE)
-            {
-                return res;
-            }
+            return res;
         }
-        return Result::RESULT_TRUE;
     }
+    return Result::RESULT_TRUE;
+}
 
-    MPolyConstraintSet MPolyConstraintSet::getMPConstraints(const std::vector<GVN::Value *> & values) const
+MPolyConstraintSet MPolyConstraintSet::getMPConstraints(const std::vector<GVN::Value *> & values) const
+{
+    MPolyConstraintSet set(constraints.size());
+    const std::vector<const MultivariatePolynomial *> args = InferenceConstraint::getArgs(values);
+    for (const auto & constraint : constraints)
     {
-        MPolyConstraintSet set(constraints.size());
-        const std::vector<const MultivariatePolynomial *> args = InferenceConstraint::getArgs(values);
-        for (const auto & constraint : constraints)
-        {
-            set.add(constraint.poly.eval(args), constraint.kind);
-        }
-        return set;
+        set.add(constraint.poly.eval(args), constraint.kind);
     }
+    return set;
+}
 
-    void MPolyConstraintSet::applyConstraints(const std::vector<GVN::Value *> & values) const
+void MPolyConstraintSet::applyConstraints(const std::vector<GVN::Value *> & values) const
+{
+    for (const auto & mpc : constraints)
     {
-        for (const auto & mpc : constraints)
-        {
-            mpc.applyConstraints(values);
-        }
+        mpc.applyConstraints(values);
     }
+}
 
-    InferenceConstraint::Result PositiveConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+InferenceConstraint::Result PositiveConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+{
+    const GVN::Value & x = *values[0];
+
+    if (x.poly->isCoeffPositive())
+    {
+        return Result::RESULT_TRUE;
+    }
+    else if (x.poly->isConstant() && x.poly->constant < 0)
     {
-        const GVN::Value & x = *values[0];
+        return Result::RESULT_FALSE;
+    }
 
-        if (x.poly->isCoeffPositive())
-        {
-            return Result::RESULT_TRUE;
-        }
-        else if (x.poly->isConstant() && x.poly->constant < 0)
-        {
-            return Result::RESULT_FALSE;
-        }
+    return Result::RESULT_DUNNO;
+}
 
-        return Result::RESULT_DUNNO;
-    }
+void PositiveConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const { }
 
-    void PositiveConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const { }
+MPolyConstraintSet PositiveConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
+{
+    MPolyConstraintSet set(1);
+    const GVN::Value & x = *values[0];
 
-    MPolyConstraintSet PositiveConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
-    {
-        MPolyConstraintSet set(1);
-        const GVN::Value & x = *values[0];
+    set.add(*x.poly, MPolyConstraint::Kind::GEQ0);
 
-        set.add(*x.poly, MPolyConstraint::Kind::GEQ0);
+    return set;
+}
 
-        return set;
-    }
+InferenceConstraint::Result StrictPositiveConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+{
+    const GVN::Value & x = *values[0];
 
-    InferenceConstraint::Result StrictPositiveConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+    if (x.poly->isCoeffStrictPositive())
     {
-        const GVN::Value & x = *values[0];
+        return Result::RESULT_TRUE;
+    }
+    else if (x.poly->isConstant() && x.poly->constant <= 0)
+    {
+        return Result::RESULT_FALSE;
+    }
 
-        if (x.poly->isCoeffStrictPositive())
-        {
-            return Result::RESULT_TRUE;
-        }
-        else if (x.poly->isConstant() && x.poly->constant <= 0)
-        {
-            return Result::RESULT_FALSE;
-        }
+    return Result::RESULT_DUNNO;
+}
 
-        return Result::RESULT_DUNNO;
-    }
+void StrictPositiveConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const { }
 
-    void StrictPositiveConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const { }
+MPolyConstraintSet StrictPositiveConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
+{
+    MPolyConstraintSet set(1);
+    const GVN::Value & x = *values[0];
 
-    MPolyConstraintSet StrictPositiveConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
-    {
-        MPolyConstraintSet set(1);
-        const GVN::Value & x = *values[0];
+    set.add(*x.poly, MPolyConstraint::Kind::GT0);
+
+    return set;
+}
 
-        set.add(*x.poly, MPolyConstraint::Kind::GT0);
+InferenceConstraint::Result StrictGreaterConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+{
+    const GVN::Value & x = *values[0];
+    const GVN::Value & y = *values[1];
 
-        return set;
+    if (x.value == y.value)
+    {
+        return Result::RESULT_FALSE;
     }
-    
-    InferenceConstraint::Result StrictGreaterConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+
+    MultivariatePolynomial mp = *x.poly - *y.poly;
+    if (mp.constant > 0 && mp.isCoeffPositive(false))
     {
-        const GVN::Value & x = *values[0];
-        const GVN::Value & y = *values[1];
+        return Result::RESULT_TRUE;
+    }
+    else if (mp.constant < 0 && mp.isCoeffNegative(false))
+    {
+        return Result::RESULT_FALSE;
+    }
 
-        if (x.value == y.value)
-        {
-            return Result::RESULT_FALSE;
-        }
+    return Result::RESULT_DUNNO;
+}
 
-        MultivariatePolynomial mp = *x.poly - *y.poly;
-        if (mp.constant > 0 && mp.isCoeffPositive(false))
-        {
-            return Result::RESULT_TRUE;
-        }
-        else if (mp.constant < 0 && mp.isCoeffNegative(false))
-        {
-            return Result::RESULT_FALSE;
-        }
+void StrictGreaterConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const { }
 
-        return Result::RESULT_DUNNO;
-    }
+MPolyConstraintSet StrictGreaterConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
+{
+    MPolyConstraintSet set(1);
+    const GVN::Value & x = *values[0];
+    const GVN::Value & y = *values[1];
 
-    void StrictGreaterConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const { }
+    set.add(*x.poly - *y.poly, MPolyConstraint::Kind::GT0);
 
-    MPolyConstraintSet StrictGreaterConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
-    {
-        MPolyConstraintSet set(1);
-        const GVN::Value & x = *values[0];
-        const GVN::Value & y = *values[1];
+    return set;
+}
 
-        set.add(*x.poly - *y.poly, MPolyConstraint::Kind::GT0);
+InferenceConstraint::Result GreaterConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+{
+    const GVN::Value & x = *values[0];
+    const GVN::Value & y = *values[1];
 
-        return set;
+    if (x.value == y.value)
+    {
+        return Result::RESULT_TRUE;
     }
 
-    InferenceConstraint::Result GreaterConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+    MultivariatePolynomial mp = *x.poly - *y.poly;
+    if (mp.isCoeffPositive(true))
     {
-        const GVN::Value & x = *values[0];
-        const GVN::Value & y = *values[1];
+        return Result::RESULT_TRUE;
+    }
+    else if (mp.constant < 0 && mp.isCoeffNegative(false))
+    {
+        return Result::RESULT_FALSE;
+    }
 
-        if (x.value == y.value)
-        {
-            return Result::RESULT_TRUE;
-        }
+    return Result::RESULT_DUNNO;
+}
 
-        MultivariatePolynomial mp = *x.poly - *y.poly;
-        if (mp.isCoeffPositive(true))
+void GreaterConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const { }
+
+MPolyConstraintSet GreaterConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
+{
+    MPolyConstraintSet set(1);
+    const GVN::Value & x = *values[0];
+    const GVN::Value & y = *values[1];
+
+    set.add(*x.poly - *y.poly, MPolyConstraint::Kind::GEQ0);
+
+    return set;
+}
+
+InferenceConstraint::Result ValidIndexConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+{
+    const GVN::Value & index = *values[0];
+    const GVN::Value & max = *values[1];
+    if (index.poly->constant > 0 && index.poly->isCoeffPositive(false))
+    {
+        // the index is geq than 1
+        MultivariatePolynomial mp = *max.poly - *index.poly;
+        if (mp.isCoeffPositive())
         {
+            // max - index >= 0
             return Result::RESULT_TRUE;
         }
-        else if (mp.constant < 0 && mp.isCoeffNegative(false))
+        else if (mp.isConstant() && mp.constant < 0)
         {
             return Result::RESULT_FALSE;
         }
-
-        return Result::RESULT_DUNNO;
     }
+    else if (index.poly->isConstant() && index.poly->constant < 1)
+    {
+        return Result::RESULT_FALSE;
+    }
+
+    return Result::RESULT_DUNNO;
+}
 
-    void GreaterConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const { }
+void ValidIndexConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const { }
 
-    MPolyConstraintSet GreaterConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
-    {
-        MPolyConstraintSet set(1);
-        const GVN::Value & x = *values[0];
-        const GVN::Value & y = *values[1];
+MPolyConstraintSet ValidIndexConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
+{
+    MPolyConstraintSet set(2);
+    const GVN::Value & index = *values[0];
+    const GVN::Value & max = *values[1];
 
-        set.add(*x.poly - *y.poly, MPolyConstraint::Kind::GEQ0);
+    set.add(*max.poly - *index.poly, MPolyConstraint::Kind::GEQ0);
+    set.add(*index.poly - 1, MPolyConstraint::Kind::GEQ0);
 
-        return set;
-    }
+    return set;
+}
+
+InferenceConstraint::Result ValidRangeConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+{
+    const GVN::Value & index_min = *values[0];
+    const GVN::Value & index_max = *values[1];
+    const GVN::Value & min = *values[2];
+    const GVN::Value & max = *values[3];
 
-    InferenceConstraint::Result ValidIndexConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
+    MultivariatePolynomial mp_min = *index_min.poly - *min.poly;
+    if (mp_min.isCoeffPositive())
     {
-        const GVN::Value & index = *values[0];
-        const GVN::Value & max = *values[1];
-        if (index.poly->constant > 0 && index.poly->isCoeffPositive(false))
+        MultivariatePolynomial mp_max = *max.poly - *index_max.poly;
+        if (mp_max.isCoeffPositive())
         {
-            // the index is geq than 1
-            MultivariatePolynomial mp = *max.poly - *index.poly;
-            if (mp.isCoeffPositive())
-            {
-                // max - index >= 0
-                return Result::RESULT_TRUE;
-            }
-            else if (mp.isConstant() && mp.constant < 0)
-            {
-                return Result::RESULT_FALSE;
-            }
+            return Result::RESULT_TRUE;
         }
-        else if (index.poly->isConstant() && index.poly->constant < 1)
+        else if (mp_max.isConstant() && mp_max.constant < 0)
         {
             return Result::RESULT_FALSE;
         }
-
-        return Result::RESULT_DUNNO;
     }
-
-    void ValidIndexConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const { }
-
-    MPolyConstraintSet ValidIndexConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
+    else if (mp_min.isConstant() && mp_min.constant < 0)
     {
-        MPolyConstraintSet set(2);
-        const GVN::Value & index = *values[0];
-        const GVN::Value & max = *values[1];
-
-        set.add(*max.poly - *index.poly, MPolyConstraint::Kind::GEQ0);
-        set.add(*index.poly - 1, MPolyConstraint::Kind::GEQ0);
-
-        return set;
+        return Result::RESULT_FALSE;
     }
 
-    InferenceConstraint::Result ValidRangeConstraint::check(GVN & gvn, const std::vector<GVN::Value *> & values) const
-    {
-        const GVN::Value & index_min = *values[0];
-       const GVN::Value & index_max = *values[1];
-        const GVN::Value & min = *values[2];
-       const GVN::Value & max = *values[3];
-
-       MultivariatePolynomial mp_min = *index_min.poly - *min.poly;
-       if (mp_min.isCoeffPositive())
-       {
-           MultivariatePolynomial mp_max = *max.poly - *index_max.poly;
-           if (mp_max.isCoeffPositive())
-           {
-               return Result::RESULT_TRUE;
-           }
-           else if (mp_max.isConstant() && mp_max.constant < 0)
-            {
-                return Result::RESULT_FALSE;
-            }
-       }
-       else if (mp_min.isConstant() && mp_min.constant < 0)
-       {
-           return Result::RESULT_FALSE;
-       }
-       
-        return Result::RESULT_DUNNO;
-    }
+    return Result::RESULT_DUNNO;
+}
 
-    void ValidRangeConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const { }
+void ValidRangeConstraint::applyConstraints(const std::vector<GVN::Value *> & values) const { }
 
-    MPolyConstraintSet ValidRangeConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
-    {
-        MPolyConstraintSet set(4);
-       const GVN::Value & index_min = *values[0];
-       const GVN::Value & index_max = *values[1];
-        const GVN::Value & min = *values[2];
-       const GVN::Value & max = *values[3];
+MPolyConstraintSet ValidRangeConstraint::getMPConstraints(const std::vector<GVN::Value *> & values) const
+{
+    MPolyConstraintSet set(4);
+    const GVN::Value & index_min = *values[0];
+    const GVN::Value & index_max = *values[1];
+    const GVN::Value & min = *values[2];
+    const GVN::Value & max = *values[3];
 
-        set.add(*index_min.poly - *min.poly, MPolyConstraint::Kind::GEQ0);
-        set.add(*max.poly - *index_max.poly, MPolyConstraint::Kind::GEQ0);
+    set.add(*index_min.poly - *min.poly, MPolyConstraint::Kind::GEQ0);
+    set.add(*max.poly - *index_max.poly, MPolyConstraint::Kind::GEQ0);
 
-        return set;
-    }
+    return set;
+}
 }