OptimizationLoopDetect<Product> for Product::optimize

ohhmm · Sep 15, 2024 · 6c2da86 · 6c2da86
1 parent 1989e76
commit 6c2da86
Show file tree

Hide file tree

Showing 9 changed files with 80 additions and 62 deletions.
diff --git a/omnn/math/Cache.cpp b/omnn/math/Cache.cpp
@@ -3,7 +3,6 @@
 //
 #include "Cache.h"
 
-#include <chrono>
 #include <iostream>
 #include <thread>
 

diff --git a/omnn/math/Cache.h b/omnn/math/Cache.h
@@ -15,8 +15,7 @@ class DB;
 
 #include <storage/CacheBase.h>
 
-#include "VarHost.h"
-#include "Variable.h"
+#include <omnn/math/VarHost.h>
 
 
 namespace omnn::math {

diff --git a/omnn/math/Integer.h b/omnn/math/Integer.h
@@ -3,8 +3,8 @@
 //
 
 #pragma once
+#include <omnn/math/ValuableDescendantContract.h>
 #include <type_traits>
-#include "ValuableDescendantContract.h"
 
 namespace omnn{
 namespace math {

diff --git a/omnn/math/Product.cpp b/omnn/math/Product.cpp
@@ -253,6 +253,13 @@ namespace math {
         if (!optimizations || optimized)
             return;
         MarkAsOptimized();
+        OptimizationLoopDetect<Product> antilooper(*this);
+        if (antilooper.isLoopDetected()) {
+#if !defined(NDEBUG) && !defined(NOOMDEBUG)
+            LOG_AND_IMPLEMENT("Loop of optimizating detected in " << *this);
+#endif
+            return;
+        }
 
         auto isPlusMinus = YesNoMaybe::Maybe;
         auto IsPlusMinus = [&] {
@@ -1121,6 +1128,49 @@ namespace math {
         return isLess;
     }
 
+    bool Product::operator ==(const Product& value) const
+    {
+        bool same = {};
+        auto& c1 = GetConstCont();
+        auto& c2 = value.GetConstCont();
+        auto sz1 = c1.size();
+        auto sz2 = c2.size();
+        auto sameSizes = sz1 == sz2;
+        if(sameSizes) {
+            same = c1 == c2;
+        } else if (sz1-sz2==1 || sz2-sz1==1) {
+            auto it1 = c1.begin(), it2 = c2.begin();
+            auto e1 = c1.end(), e2 = c2.end();
+            for(same = true;
+                same && it1 != e1 && it2 != e2;
+                ++it1, ++it2)
+            {
+                if(it1->Same(1_v)){
+                    ++it1;
+                }
+                if(it2->Same(1_v)){
+                    ++it2;
+                }
+
+                if(it1 == e1 || it2 == e2)
+                    continue;
+
+                same = same && it1->Same(*it2);
+            }
+
+            same = same && it1 == e1 && it2 == e2;
+        } else {
+            same = {};
+        }
+        if (!same // TODO: Check if it has same multival exponentiation and different sign or i in coefficient
+            && IsMultival() == YesNoMaybe::Yes
+            && value.IsMultival() == YesNoMaybe::Yes)
+        {
+            //LOG_AND_IMPLEMENT("Check if it has same multival exponentiation and different sign or i in coefficient: " << *this << " == " << v);
+        }
+        return same;
+    }
+
     namespace {
         constexpr std::hash<a_int> Hasher;
         const size_t Hash1 = Hasher(1);
@@ -1130,42 +1180,12 @@ namespace math {
         auto sameHash = (Valuable::hash & ~Hash1) == (v.Hash() & ~Hash1); // ignore multiplication by 1
         auto same = v.Is<Product>() && sameHash;
         auto& c1 = GetConstCont();
-        auto sz1 = c1.size();
         if (same) {
-            auto& vp = v.as<Product>();
-            auto& c2 = vp.GetConstCont();
-            auto sz2 = c2.size();
-            auto sameSizes = sz1 == sz2;
-            if(sameSizes) {
-                same = c1 == c2;                
-            } else if (sz1-sz2==1 || sz2-sz1==1) {
-                auto it1 = c1.begin(), it2 = c2.begin();
-                auto e1 = c1.end(), e2 = c2.end();                    
-                for(same = true;
-                    same && it1 != e1 && it2 != e2;
-                    ++it1, ++it2)
-                {
-                    if(it1->Same(1_v)){
-                        ++it1;
-                    }
-                    if(it2->Same(1_v)){
-                        ++it2;
-                    }
-
-                    if(it1 == e1 || it2 == e2)
-                        continue;
-
-                    same = same && it1->Same(*it2);
-                }
-
-                same = same && it1 == e1 && it2 == e2;
-            } else {
-                same = {};
-            }
+            same = operator ==(v.as<Product>());
         }
-        else if (sameHash
-                 && (sz1 == 1
-                     || (sz1 == 2 && c1.begin()->Same(1_v) )))
+        else if (size_t sz1; sameHash
+                             && ((sz1 = c1.size()) == 1
+                                 || (sz1 == 2 && c1.begin()->Same(1_v) )))
         {
             same = c1.rbegin()->operator==(v);
         } else if (members.empty()) {
@@ -1187,12 +1207,6 @@ namespace math {
                     }
                 }
             }
-        } else if (v.IsProduct()
-            && IsMultival() == YesNoMaybe::Yes
-            && v.IsMultival() == YesNoMaybe::Yes)
-        {
-            // TODO: Check if it has same multival exponentiation and different sign or i in coefficient
-            //LOG_AND_IMPLEMENT("Check if it has same multival exponentiation and different sign or i in coefficient: " << *this << " == " << v);
         }
         return same;
     }

diff --git a/omnn/math/Product.h b/omnn/math/Product.h
@@ -75,6 +75,7 @@ class Product
     Valuable& operator /=(const Valuable& v) override;
     Valuable& operator %=(const Valuable& v) override;
     Valuable& operator ^=(const Valuable& v) override;
+    bool operator ==(const Product& v) const;
     bool operator ==(const Valuable& v) const override;
     bool operator<(const Valuable& v) const override;
     Valuable Sign() const override;

diff --git a/omnn/math/Valuable.h b/omnn/math/Valuable.h
@@ -87,6 +87,9 @@ extern const Variable& integration_result_constant;
     class VarHost;
     struct ValuableDescendantMarker {};
 
+    Valuable implement(const char* str = "");
+
+
 class Valuable
         : public OpenOps<Valuable>
 {
@@ -660,9 +663,6 @@ class Valuable
     //   TODO : std::shared_ptr<std::vector<Valuable>> cachedValues;
 };
 
-
-Valuable implement(const char* str = "");
-
 template<class T>
 const T& Valuable::as() const {
     auto& the = get();

diff --git a/omnn/math/ValuableDescendantContract.cpp b/omnn/math/ValuableDescendantContract.cpp
@@ -57,4 +57,9 @@ Valuable ValuableDescendantBase::Univariate() const {
 	return uni;
 }
 
-}}
+Valuable ValuableDescendantBase::Sqrt() const {
+    LOG_AND_IMPLEMENT("Implement Sqrt method for " << *this);
+}
+
+} // namespace math
+} // namespace omnn
diff --git a/omnn/math/ValuableDescendantContract.h b/omnn/math/ValuableDescendantContract.h
@@ -30,8 +30,8 @@ namespace math {
 
         void optimize() override { }
         //void expand() override { }
-        Valuable Sqrt() const override { IMPLEMENT }
-        
+        Valuable Sqrt() const override;
+
         bool IsComesBefore(const Valuable& v) const override
         {
             return *this > v;

diff --git a/omnn/math/VarHost.h b/omnn/math/VarHost.h
@@ -18,8 +18,8 @@
 
 #include <boost/any.hpp>
 
-#include "Integer.h"
-#include "Variable.h"
+#include <omnn/math/Integer.h>
+#include <omnn/math/Variable.h>
 
 namespace omnn {
 namespace math {
@@ -35,34 +35,34 @@ namespace math {
 
     public:
         using ptr = std::shared_ptr<VarHost>;
-        using cptr = std::shared_ptr<const VarHost>;
+        using cptr = std::shared_ptr<const VarHost>;
         using cref = const VarHost&;
         using hosted_storage_t = std::pair<Variable, std::string>;
 
         virtual ~VarHost() = default;
 
         template<class T>
         Variable New(const T& id) {
-#ifndef NDEBUG
+#ifndef NDEBUG
             auto host = dynamic_cast<TypedVarHost<T>*>(this);
-            if (host != this) {
-                LOG_AND_IMPLEMENT("wrong id type");
-            }
-#endif
+            if (host != this) {
+                LOG_AND_IMPLEMENT("wrong id type");
+            }
+#endif
                 Variable v(sh());
                 v.SetId(id);
                 return v;
             }
 
-		Variable New();
+		Variable New();
 
     protected:
         VarHost() = default;
 
         const any::any& GetId(const Variable&) const;
 
-        Variable New(const any::any& id);
-
+        Variable New(const any::any& id);
+
         virtual void AddNewId(const void* id) {
             IMPLEMENT;
         }
@@ -223,7 +223,7 @@ namespace math {
                 const T& idT = *idTp;
                 it = hosted.find(idT);
                 if (it == hosted.end()) {
-                    it = hosted.emplace(idT, hosted_storage_t{New(id), ""s}).first;
+                    it = hosted.emplace(idT, hosted_storage_t{New(id), ""s}).first;
                 }
             }