Merge remote-tracking branch 'origin/master' into windows
[scilab.git] / scilab / modules / ast / src / cpp / analysis / MultivariateMonomial.cpp
index 0440d10..2cf5e89 100644 (file)
@@ -2,11 +2,14 @@
  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  *  Copyright (C) 2015 - Scilab Enterprises - Calixte DENIZET
  *
- *  This file must be used under the terms of the CeCILL.
- *  This source file is licensed as described in the file COPYING, which
- *  you should have received as part of this distribution.  The terms
- *  are also available at
- *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ * Copyright (C) 2012 - 2016 - Scilab Enterprises
+ *
+ * This file is hereby licensed under the terms of the GNU GPL v2.0,
+ * pursuant to article 5.3.4 of the CeCILL v.2.1.
+ * This file was originally licensed under the terms of the CeCILL v2.1,
+ * and continues to be available under such terms.
+ * For more information, see the COPYING file which you should have received
+ * along with this program.
  *
  */
 
 namespace analysis
 {
 
-    bool MultivariateMonomial::contains(const uint64_t var) const
-       {
-           return monomial.find(var) != monomial.end();
-       }
-    
-    bool MultivariateMonomial::checkVariable(const uint64_t max) const
-    {
-       return std::prev(monomial.end())->var <= max;
-    }
+bool MultivariateMonomial::contains(const uint64_t var) const
+{
+    return monomial.find(var) != monomial.end();
+}
 
-    unsigned int MultivariateMonomial::exponent() const
-    {
-        unsigned int exp = 0;
-        for (const auto & ve : monomial)
-        {
-            exp += ve.exp;
-        }
-        return exp;
-    }
+bool MultivariateMonomial::checkVariable(const uint64_t max) const
+{
+    return std::prev(monomial.end())->var <= max;
+}
 
-    MultivariateMonomial & MultivariateMonomial::add(const VarExp & ve)
+unsigned int MultivariateMonomial::exponent() const
+{
+    unsigned int exp = 0;
+    for (const auto & ve : monomial)
     {
-        Monomial::iterator i = monomial.find(ve);
-        if (i == monomial.end())
-        {
-            monomial.insert(ve);
-        }
-        else
-        {
-            i->exp += ve.exp;
-        }
-        return *this;
+        exp += ve.exp;
     }
+    return exp;
+}
 
-    MultivariateMonomial & MultivariateMonomial::add(VarExp && ve)
+MultivariateMonomial & MultivariateMonomial::add(const VarExp & ve)
+{
+    Monomial::iterator i = monomial.find(ve);
+    if (i == monomial.end())
     {
-        Monomial::iterator i = monomial.find(ve);
-        if (i == monomial.end())
-        {
-            monomial.emplace(std::move(ve));
-        }
-        else
-        {
-            i->exp += ve.exp;
-        }
-        return *this;
+        monomial.insert(ve);
     }
-
-    MultivariateMonomial MultivariateMonomial::operator*(const MultivariateMonomial & R) const
+    else
     {
-        MultivariateMonomial res(*this);
-        res.coeff *= R.coeff;
-        for (const auto & ve : R.monomial)
-        {
-            res.add(ve);
-        }
-        return res;
+        i->exp += ve.exp;
     }
+    return *this;
+}
 
-    MultivariateMonomial & MultivariateMonomial::operator*=(const MultivariateMonomial & R)
+MultivariateMonomial & MultivariateMonomial::add(VarExp && ve)
+{
+    Monomial::iterator i = monomial.find(ve);
+    if (i == monomial.end())
     {
-        coeff *= R.coeff;
-        for (const auto & ve : R.monomial)
-        {
-            add(ve);
-        }
-        return *this;
+        monomial.emplace(std::move(ve));
     }
-
-    MultivariateMonomial operator*(const int64_t L, const MultivariateMonomial & R)
+    else
     {
-        return R * L;
+        i->exp += ve.exp;
     }
+    return *this;
+}
 
-    MultivariateMonomial MultivariateMonomial::operator*(const int64_t R) const
+MultivariateMonomial MultivariateMonomial::operator*(const MultivariateMonomial & R) const
+{
+    MultivariateMonomial res(*this);
+    res.coeff *= R.coeff;
+    for (const auto & ve : R.monomial)
     {
-        MultivariateMonomial res(*this);
-        res.coeff *= R;
-        return res;
+        res.add(ve);
     }
+    return res;
+}
 
-    MultivariateMonomial & MultivariateMonomial::operator*=(const int64_t R)
+MultivariateMonomial & MultivariateMonomial::operator*=(const MultivariateMonomial & R)
+{
+    coeff *= R.coeff;
+    for (const auto & ve : R.monomial)
     {
-        coeff *= R;
-        return *this;
+        add(ve);
     }
+    return *this;
+}
 
-    MultivariateMonomial MultivariateMonomial::operator/(const int64_t R) const
-    {
-        MultivariateMonomial res(*this);
-        res.coeff /= R;
-        return res;
-    }
+MultivariateMonomial operator*(const int64_t L, const MultivariateMonomial & R)
+{
+    return R * L;
+}
+
+MultivariateMonomial MultivariateMonomial::operator*(const int64_t R) const
+{
+    MultivariateMonomial res(*this);
+    res.coeff *= R;
+    return res;
+}
+
+MultivariateMonomial & MultivariateMonomial::operator*=(const int64_t R)
+{
+    coeff *= R;
+    return *this;
+}
+
+MultivariateMonomial MultivariateMonomial::operator/(const int64_t R) const
+{
+    MultivariateMonomial res(*this);
+    res.coeff /= R;
+    return res;
+}
+
+MultivariateMonomial & MultivariateMonomial::operator/=(const int64_t R)
+{
+    coeff /= R;
+    return *this;
+}
 
-    MultivariateMonomial & MultivariateMonomial::operator/=(const int64_t R)
+MultivariateMonomial MultivariateMonomial::operator^(unsigned int R) const
+{
+    MultivariateMonomial res(*this);
+    if (R > 1)
     {
-        coeff /= R;
-        return *this;
+        coeff = std::pow(coeff, R);
+        for (auto & ve : res.monomial)
+        {
+            ve.exp *= R;
+        }
     }
+    return res;
+}
+
+bool MultivariateMonomial::operator==(const MultivariateMonomial & R) const
+{
+    return coeff == R.coeff && monomial == R.monomial;
+}
 
-    MultivariateMonomial MultivariateMonomial::operator^(unsigned int R) const
+const std::string MultivariateMonomial::print(const std::map<uint64_t, std::string> & vars) const
+{
+    std::ostringstream os;
+    if (coeff == -1 || coeff == 1)
     {
-        MultivariateMonomial res(*this);
-        if (R > 1)
+        if (coeff == -1)
         {
-            coeff = std::pow(coeff, R);
-            for (auto & ve : res.monomial)
+            os << L'-';
+        }
+        if (!monomial.empty())
+        {
+            os << monomial.begin()->print(vars);
+            for (auto i = std::next(monomial.begin()), e = monomial.end(); i != e; ++i)
             {
-                ve.exp *= R;
+                os << "*" << i->print(vars);
             }
         }
-        return res;
     }
-
-    bool MultivariateMonomial::operator==(const MultivariateMonomial & R) const
+    else
     {
-        return coeff == R.coeff && monomial == R.monomial;
+        os << coeff;
+        for (const auto & ve : monomial)
+        {
+            os << "*" << ve.print(vars);
+        }
     }
+    return os.str();
+}
 
-    const std::wstring MultivariateMonomial::print(const std::map<uint64_t, std::wstring> & vars) const
-    {
-        std::wostringstream wos;
-       if (coeff == 1)
-       {
-           if (!monomial.empty())
-           {
-               wos << monomial.begin()->print(vars);
-               for (auto i = std::next(monomial.begin()), e = monomial.end(); i != e; ++i)
-               {
-                   wos << L"*" << i->print(vars);
-               }
-           }
-       }
-       else
-       {
-           wos << coeff;
-           for (const auto & ve : monomial)
-           {
-               wos << L"*" << ve.print(vars);
-           }
-       }
-        return wos.str();
-    }
+std::ostream & operator<<(std::ostream & out, const MultivariateMonomial & m)
+{
+    const std::map<uint64_t, std::string> vars;
+    out << m.print(vars);
+
+    return out;
+}
 
-    std::wostream & operator<<(std::wostream & out, const MultivariateMonomial & m)
+bool MultivariateMonomial::Compare::operator()(const MultivariateMonomial & L, const MultivariateMonomial & R) const
+{
+    const unsigned int le = L.exponent();
+    const unsigned int re = R.exponent();
+    if (le < re)
     {
-       if (m.coeff == 1)
-       {
-           if (!m.monomial.empty())
-           {
-               out << *m.monomial.begin();
-               for (auto i = std::next(m.monomial.begin()), e = m.monomial.end(); i != e; ++i)
-               {
-                   out << L"*" << *i;
-               }
-           }
-       }
-       else
-       {
-           out << m.coeff;
-           for (const auto & ve : m.monomial)
-           {
-               out << L"*" << ve;
-           }
-       }
-        return out;
+        return true;
     }
-
-    bool MultivariateMonomial::Compare::operator()(const MultivariateMonomial & L, const MultivariateMonomial & R) const
+    else if (le == re)
     {
-            const unsigned int le = L.exponent();
-            const unsigned int re = R.exponent();
-            if (le < re)
+        const unsigned int ls = static_cast<unsigned int>(L.monomial.size());
+        const unsigned int rs = static_cast<unsigned int>(R.monomial.size());
+        if (ls > rs)
+        {
+            return true;
+        }
+        else if (ls == rs)
+        {
+            for (Monomial::const_iterator i = L.monomial.begin(), j = R.monomial.begin(), e = L.monomial.end(); i != e; ++i, ++j)
             {
-                return true;
+                if (VarExp::Compare()(*i, *j))
+                {
+                    return true;
+                }
+                else if (!VarExp::Eq()(*i, *j))
+                {
+                    return false;
+                }
             }
-            else if (le == re)
+
+            for (Monomial::const_iterator i = L.monomial.begin(), j = R.monomial.begin(), e = L.monomial.end(); i != e; ++i, ++j)
             {
-                const unsigned int ls = static_cast<unsigned int>(L.monomial.size());
-                const unsigned int rs = static_cast<unsigned int>(R.monomial.size());
-                if (ls > rs)
+                if (i->exp < j->exp)
                 {
                     return true;
                 }
-                else if (ls == rs)
+                else if (i->exp > j->exp)
                 {
-                    for (Monomial::const_iterator i = L.monomial.begin(), j = R.monomial.begin(), e = L.monomial.end(); i != e; ++i, ++j)
-                    {
-                        if (VarExp::Compare()(*i, *j))
-                        {
-                            return true;
-                        }
-                        else if (!VarExp::Eq()(*i, *j))
-                        {
-                            return false;
-                        }
-                    }
-
-                    for (Monomial::const_iterator i = L.monomial.begin(), j = R.monomial.begin(), e = L.monomial.end(); i != e; ++i, ++j)
-                    {
-                        if (i->exp < j->exp)
-                        {
-                            return true;
-                        }
-                        else if (i->exp > j->exp)
-                        {
-                            return false;
-                        }
-                    }
-
+                    return false;
                 }
             }
-            return false;
+
         }
+    }
+    return false;
+}
 
 } // namespace analysis