Merge pull request #24 from CS-24-SV-9-04/main-optimized-arcs

Optimized arcs and fixed many bugs

include/PetriEngine/ExplicitColored/ArcCompiler.h

@@ -0,0 +1,21 @@
+#ifndef ARCCOMPILER_H
+#define ARCCOMPILER_H
+
+#include "CompiledArc.h"
+#include "../Colored/Expressions.h"
+
+namespace PetriEngine {
+    namespace ExplicitColored {
+        class ArcCompiler {
+        public:
+            static CompiledArc compileArc(
+                const Colored::ArcExpression_ptr& arcExpression,
+                const std::unordered_map<std::string, Variable_t>& variableMap,
+                const Colored::ColorTypeMap& colorTypeMap
+            );
+        };
+    }
+}
+
+
+#endif //ARCCOMPILER_H

include/PetriEngine/ExplicitColored/AtomicTypes.h

@@ -10,6 +10,7 @@ namespace PetriEngine
         using Transition_t = uint32_t;
         using Variable_t = uint32_t;
         using MarkingCount_t = uint32_t;
+        using sMarkingCount_t = int32_t;
         constexpr Color_t DOT_COLOR = 0;
         constexpr Color_t ALL_COLOR = std::numeric_limits<Color_t>::max();
     }

include/PetriEngine/ExplicitColored/CPNMultiSet.h

@@ -5,13 +5,14 @@
 #include <vector>
 #include <map>
 #include <utils/errors.h>
-
+#include "SequenceMultiSet.h"
 namespace PetriEngine
 {
     namespace ExplicitColored
     {
         class ColorSequence {
         public:
+            ColorSequence() = default;
             ColorSequence(const ColorSequence&) = default;
             ColorSequence(ColorSequence&&) = default;
             ColorSequence& operator=(const ColorSequence&) = default;
@@ -35,39 +36,40 @@ namespace PetriEngine
                 return false;
             }
 
+            bool operator==(const ColorSequence& other) const {
+                if (_sequence.size() != other._sequence.size())
+                    return false;
+                for (size_t i = 0; i < _sequence.size(); i++) {
+                    if (_sequence[i] != other._sequence[i]) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            bool operator!=(const ColorSequence& other) const {
+                return !(*this == other);
+            }
+
             const std::vector<Color_t>& getSequence() const {
                 return _sequence;
             }
-        private:
-            std::vector<Color_t> _sequence;
-        };
-        struct CPNMultiSet
-        {
-            CPNMultiSet() = default;
-            CPNMultiSet(const CPNMultiSet& multiSet) {
-                    _counts = multiSet._counts;
-                    _cardinality = multiSet._cardinality;
-            };
-            CPNMultiSet(const std::map<ColorSequence, MarkingCount_t>& map, uint32_t cardinality) : _counts(map),_cardinality(cardinality) {};
-            CPNMultiSet(CPNMultiSet&&) = default;
-            CPNMultiSet& operator=(const CPNMultiSet& other) = default;
-            CPNMultiSet& operator=(CPNMultiSet&&) = default;
 
-            MarkingCount_t getCount(const ColorSequence& color) const;
-            void setCount(const ColorSequence& color, MarkingCount_t count);
-            MarkingCount_t totalCount() const;
-            CPNMultiSet& operator+=(const CPNMultiSet& other);
-            CPNMultiSet& operator-=(const CPNMultiSet& other);
-            CPNMultiSet& operator*=(MarkingCount_t scalar);
-            bool operator==(const CPNMultiSet& other) const;
-            bool operator>=(const CPNMultiSet& other) const;
-            bool operator<=(const CPNMultiSet& other) const;
+            std::vector<Color_t>& getSequence() {
+                return _sequence;
+            }
 
-            void stableEncode(std::ostream& out) const;
+            friend std::ostream& operator<<(std::ostream& os, const ColorSequence& colorSequence) {
+                for (auto color : colorSequence._sequence) {
+                    os << color << ",";
+                }
+                return os;
+            }
         private:
-            std::map<ColorSequence, MarkingCount_t> _counts = std::map<ColorSequence, MarkingCount_t>{};
-            MarkingCount_t _cardinality = 0;
+            std::vector<Color_t> _sequence;
         };
+
+        typedef SequenceMultiSet<ColorSequence> CPNMultiSet;
     }
 }
 

include/PetriEngine/ExplicitColored/ColoredMarkingSet.h

@@ -24,9 +24,16 @@ namespace PetriEngine {
                 return _set.find(stream.str()) != _set.end();
             }
 
-            size_t size() {
+            size_t size() const {
                 return _set.size();
             }
+
+            friend std::ostream& operator<<(std::ostream& stream, const ColoredMarkingSet &marking) {
+                for (const auto& hash : marking._set) {
+                    stream << hash << std::endl;
+                }
+                return stream;
+            }
         private:
             std::unordered_set<std::string> _set;
         };

include/PetriEngine/ExplicitColored/ColoredPetriNet.h

@@ -33,7 +33,7 @@
 #include "GuardExpression.h"
 #include "Binding.h"
 #include "ColoredPetriNetMarking.h"
-#include "ArcExpression.h"
+#include "CompiledArc.h"
 
 namespace PetriEngine
 {
@@ -75,7 +75,7 @@ namespace PetriEngine
             uint32_t from;
             uint32_t to;
             std::shared_ptr<ColorType> colorType;
-            std::unique_ptr<ArcExpression> arcExpression;
+            CompiledArc expression;
         };
 
         struct Variable

include/PetriEngine/ExplicitColored/ColoredPetriNetBuilder.h

@@ -20,10 +20,10 @@ namespace PetriEngine {
             void addInputArc(const std::string& place, const std::string& transition, bool inhibitor, uint32_t weight) override;
             void addOutputArc(const std::string& transition, const std::string& place, uint32_t weight) override;
 
-            void addPlace(const std::string& name, const Colored::ColorType* type, Colored::Multiset&& tokens, double, double);
+            void addPlace(const std::string& name, const Colored::ColorType* type, Colored::Multiset&& tokens, double, double) override;
             void addTransition(const std::string& name, const Colored::GuardExpression_ptr& guard, int32_t, double, double) override;
             void addInputArc(const std::string& place, const std::string& transition, const Colored::ArcExpression_ptr& expr, uint32_t inhib_weight) override;
-            void addOutputArc(const std::string& transition, const std::string& place, const Colored::ArcExpression_ptr& expr);
+            void addOutputArc(const std::string& transition, const std::string& place, const Colored::ArcExpression_ptr& expr) override;
             void addColorType(const std::string& id, const Colored::ColorType* type) override;
             void addVariable(const PetriEngine::Colored::Variable* variable) override;
 

include/PetriEngine/ExplicitColored/ColoredPetriNetMarking.h

@@ -2,7 +2,7 @@
 #define COLOREDPETRINETMARKING_H
 
 #include "vector"
-#include "MultiSet.h"
+#include "CPNMultiSet.h"
 namespace PetriEngine{
     namespace ExplicitColored{
         struct ColoredPetriNetMarking{
@@ -29,9 +29,23 @@ namespace PetriEngine{
                 return markings[placeIndex].totalCount();
             }
 
+            void shrink() {
+                for (auto& place : markings) {
+                    place.shrink();
+                }
+            }
+
             void stableEncode(std::ostream& out) const {
                 for (const auto& marking : markings) {
-                    marking.stableEncode(out);
+                    for (const auto& pair : marking.counts()) {
+                        if (pair.second > 0) {
+                            out << pair.second << "'(";
+                            for (auto c : pair.first.getSequence()) {
+                                out << c << ",";
+                            }
+                            out << ")";
+                        }
+                    }
                     out << ".";
                 }
             }

include/PetriEngine/ExplicitColored/ColoredPetriNetState.h

@@ -12,6 +12,10 @@ namespace PetriEngine{
             ColoredPetriNetState& operator=(const ColoredPetriNetState&) = default;
             ColoredPetriNetState& operator=(ColoredPetriNetState&&) = default;
 
+            void shrink() {
+                marking.shrink();
+            }
+
             ColoredPetriNetMarking marking;
             uint32_t lastTrans = 0;
             uint32_t lastBinding = 0;

include/PetriEngine/ExplicitColored/ColoredSuccessorGenerator.h

@@ -30,13 +30,13 @@ namespace PetriEngine{
                 return _net;
             }
 
-            Binding getBinding(Transition_t tid, uint32_t bid);
-            bool check(const ColoredPetriNetMarking& state, Transition_t tid, const Binding& binding);
-            bool checkInhibitor(const ColoredPetriNetMarking& state, Transition_t tid);
-            bool checkPresetAndGuard(const ColoredPetriNetMarking& state, Transition_t tid, const Binding& binding);
-            CheckingBool firstCheckPresetAndGuard(const ColoredPetriNetMarking& state, Transition_t tid, const Binding& binding);
-            void consumePreset(ColoredPetriNetMarking& state, Transition_t tid, const Binding& b);
-            void producePostset(ColoredPetriNetMarking& state, Transition_t tid, const Binding& b);
+            Binding getBinding(Transition_t tid, uint32_t bid) const;
+            bool check(const ColoredPetriNetMarking& state, Transition_t tid, const Binding& binding) const;
+            bool checkInhibitor(const ColoredPetriNetMarking& state, Transition_t tid) const;
+            bool checkPresetAndGuard(const ColoredPetriNetMarking& state, Transition_t tid, const Binding& binding) const;
+            CheckingBool firstCheckPresetAndGuard(const ColoredPetriNetMarking& state, Transition_t tid, const Binding& binding) const;
+            void consumePreset(ColoredPetriNetMarking& state, Transition_t tid, const Binding& b) const;
+            void producePostset(ColoredPetriNetMarking& state, Transition_t tid, const Binding& b) const;
         protected:
             const ColoredPetriNet& _net;
             void _fire(ColoredPetriNetMarking& state, Transition_t tid, const Binding& b);

include/PetriEngine/ExplicitColored/CompiledArc.h

@@ -0,0 +1,108 @@
+#ifndef COMPILEDARC_H
+#define COMPILEDARC_H
+#include <vector>
+#include "CPNMultiSet.h"
+#include "Binding.h"
+#include "utils/MathExt.h"
+
+namespace PetriEngine {
+    namespace ExplicitColored {
+        union ColorOrVariable {
+            Color_t color;
+            Variable_t variable;
+        };
+
+        struct ParameterizedColor {
+            int64_t offset;
+            bool isVariable;
+            //perhaps include "all" value so we dont need to materialize all colors
+            ColorOrVariable value;
+            bool operator==(const ParameterizedColor &other) const {
+                return isVariable == other.isVariable
+                    && (isVariable
+                        ? (value.variable == other.value.variable)
+                        : (value.color == other.value.color)
+                        ) && offset == other.offset;
+            }
+
+            bool operator!=(const ParameterizedColor &other) const {
+                return !(*this == other);
+            }
+
+            bool isAll() const {
+                return !isVariable && value.color == ALL_COLOR;
+            }
+
+            static ParameterizedColor fromColor(const Color_t color) {
+                ParameterizedColor rv{};
+                rv.isVariable = false;
+                rv.offset = 0;
+                rv.value.color = color;
+                return rv;
+            }
+
+            static ParameterizedColor fromVariable(const Variable_t variable) {
+                ParameterizedColor rv{};
+                rv.isVariable = true;
+                rv.offset = 0;
+                rv.value.variable = variable;
+                return rv;
+            }
+
+            static ParameterizedColor fromAll() {
+                ParameterizedColor rv{};
+                rv.isVariable = false;
+                rv.offset = 0;
+                rv.value.color = ALL_COLOR;
+                return rv;
+            }
+        };
+
+        class CompiledArc {
+        public:
+            explicit CompiledArc(
+                std::vector<std::pair<std::vector<ParameterizedColor>, sMarkingCount_t>> variableSequences,
+                CPNMultiSet constantValue,
+                std::vector<Color_t> sequenceColorSizes,
+                std::set<Variable_t> variables
+            );
+
+            [[nodiscard]] CPNMultiSet eval(const Binding& binding) const;
+            void produce(CPNMultiSet& existing, const Binding& binding) const;
+            void consume(CPNMultiSet& existing, const Binding& binding) const;
+            [[nodiscard]] bool isSubSet(const CPNMultiSet& superSet, const Binding& binding) const;
+            [[nodiscard]] const std::set<Variable_t>& getVariables() const {
+                return _variables;
+            }
+            MarkingCount_t getMinimalMarkingCount() const;
+
+            friend std::ostream& operator<<(std::ostream& out, const CompiledArc& arc) {
+                out << "constant: " << arc._constantValue << " variables: ";
+                for (const auto& [colorSequence, count] : arc._variableSequences) {
+                    std::cout << count << "'(";
+                    for (auto color : colorSequence) {
+                        if (color.isVariable) {
+                            std::cout << "v";
+                        }
+                        std::cout << color.value.color << "+" << color.offset << ",";
+                    }
+                    std::cout << ")";
+                }
+                return out;
+            }
+        private:
+            void setBurnerSequence(const std::vector<ParameterizedColor>& parameterizedColorSequence, const Binding& binding) const;
+            void addVariables(CPNMultiSet& target, const Binding& binding) const;
+
+            std::vector<std::pair<std::vector<ParameterizedColor>, sMarkingCount_t>> _variableSequences;
+            CPNMultiSet _constantValue;
+            std::vector<Color_t> _sequenceColorSizes;
+            std::set<Variable_t> _variables;
+            bool hasNegative;
+            mutable ColorSequence _burner;
+            MarkingCount_t _minimalMarkingCount;
+        };
+    }
+}
+
+#endif