Repair CI (Temporary solution)

include/core/truthTable/dd_synthesis.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "core/truthTable/truth_table.hpp"
+
+namespace syrec {
+
+    void rootPath(dd::mNode* src, dd::mNode* dst, TruthTable::Cube::Vector& sigVec, TruthTable::Cube& tempVec);
+
+    void sigPath(dd::mNode* src, TruthTable::Cube::Vector& sigVec, TruthTable::Cube& tempVec);
+
+    bool algoP3(dd::mNode* current);
+
+    void algoP4(dd::mEdge& src, dd::mNode* current, syrec::TruthTable::Cube::Vector& p1SigVec, syrec::TruthTable::Cube::Vector& p2SigVec, const std::vector<std::size_t>& indices, std::unique_ptr<dd::Package<>>& dd);
+
+    void algoP1(dd::mEdge& src, dd::mNode* current, std::unique_ptr<dd::Package<>>& dd);
+
+    void algoP2(dd::mEdge& src, dd::mNode* current, std::unique_ptr<dd::Package<>>& dd);
+
+    void algoP(dd::mEdge& src, dd::mNode* current, std::unique_ptr<dd::Package<>>& dd);
+
+    void algoQ(dd::mEdge& src, std::unique_ptr<dd::Package<>>& dd);
+} // namespace syrec

include/core/truthTable/pla_parser.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "core/truthTable/truth_table.hpp"
+
+namespace syrec {
+
+    [[maybe_unused]] inline syrec::TruthTable::Cube::Value transform_pla_to_constants(const char& c) {
+        syrec::TruthTable::Cube::Value constant;
+        syrec::TruthTable::Cube::Value one  = true;
+        syrec::TruthTable::Cube::Value zero = false;
+        switch (c) {
+            case '-':
+            case '~':
+                return constant;
+
+            case '0':
+                return zero;
+            case '1':
+                return one;
+
+            default:
+                assert(false);
+                return constant;
+        }
+    }
+
+    [[maybe_unused]] inline std::string trim(std::string& str) {
+        str.erase(str.find_last_not_of(' ') + 1); //suffixing spaces
+        str.erase(0, str.find_first_not_of(' ')); //prefixing spaces
+        return str;
+    }
+
+    [[maybe_unused]] void pla_parser(std::istream& in, syrec::TruthTable& reader);
+
+    [[maybe_unused]] void read_pla(TruthTable& spec, std::istream& in);
+
+    bool read_pla(TruthTable& spec, const std::string& filename);
+
+} // namespace syrec

include/core/truthTable/truth_table.hpp

@@ -0,0 +1,211 @@
+#pragma once
+
+#include "dd/Package.hpp"
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <iostream>
+#include <iterator>
+#include <map>
+#include <memory>
+#include <optional>
+#include <queue>
+#include <utility>
+#include <vector>
+
+namespace syrec {
+
+    class TruthTable {
+    public:
+        class Cube {
+        public:
+            using Value  = std::optional<bool>;
+            using Vector = std::vector<Cube>;
+
+        private:
+            std::vector<Value> cube{};
+
+        public:
+            Cube() = default;
+            explicit Cube(std::vector<Value> cube):
+                cube(std::move(cube)) {}
+
+            Cube(const std::size_t bw, const Value& initializer) {
+                cube.resize(bw, initializer);
+            }
+
+            template<class InputIt>
+            Cube(InputIt first, InputIt last) {
+                std::copy(first, last, std::back_inserter(cube));
+            }
+
+            // construct a cube from a (64bit) number with a given bitwidth
+            static auto fromInteger(const std::uint64_t number, const std::size_t bw) -> Cube {
+                assert(bw <= 64U);
+                Cube cube{};
+                cube.reserve(bw);
+                for (std::size_t i = 0U; i < bw; ++i) {
+                    cube.emplace_back((number & (1ULL << (bw - 1U - i))) != 0U);
+                }
+                return cube;
+            }
+            // return integer representation of the cube
+            [[nodiscard]] auto toInteger() const -> std::uint64_t {
+                assert(cube.size() <= 64U);
+                assert(std::none_of(cube.cbegin(), cube.cend(), [](auto const& v) { return !v.has_value(); }));
+                std::uint64_t result = 0U;
+                for (std::size_t i = 0U; i < cube.size(); ++i) {
+                    if (*cube[i]) {
+                        result |= (1ULL << (cube.size() - 1U - i));
+                    }
+                }
+                return result;
+            }
+
+            [[nodiscard]] auto completeCubes() const -> Vector;
+
+            auto insertZero() -> void {
+                cube.insert(cube.begin(), false);
+            }
+            [[nodiscard]] auto append(const Value& v) const -> Cube {
+                auto c = cube;
+                c.emplace_back(v);
+                return Cube(c);
+            }
+            [[nodiscard]] auto appendZero() const -> Cube {
+                return append(false);
+            }
+            [[nodiscard]] auto appendOne() const -> Cube {
+                return append(true);
+            }
+
+            // pass-through functions for underlying vector
+
+            auto at(std::size_t pos) -> Value& {
+                return cube[pos];
+            }
+
+            auto operator[](std::size_t pos) const -> Value {
+                return cube[pos];
+            }
+
+            auto operator<(const Cube& cv) const -> bool {
+                return (cube < cv.cube);
+            }
+
+            auto operator==(const Cube& cv) const -> bool {
+                return (cube == cv.cube);
+            }
+
+            auto reserve(const std::size_t n) -> void {
+                cube.reserve(n);
+            }
+            auto resize(const std::size_t n, const Value& val = Value()) -> void {
+                cube.resize(n, val);
+            }
+            auto emplace_back(const Value& v) -> void {
+                cube.emplace_back(v);
+            }
+
+            auto pop_back() -> void {
+                cube.pop_back();
+            }
+
+            [[nodiscard]] auto size() const -> std::size_t {
+                return cube.size();
+            }
+            [[nodiscard]] auto empty() const -> bool {
+                return cube.empty();
+            }
+            [[nodiscard]] auto begin() const -> decltype(cube.begin()) {
+                return cube.begin();
+            }
+            [[nodiscard]] auto cbegin() const -> decltype(cube.cbegin()) {
+                return cube.cbegin();
+            }
+            [[nodiscard]] auto end() const -> decltype(cube.end()) {
+                return cube.end();
+            }
+            [[nodiscard]] auto cend() const -> decltype(cube.cend()) {
+                return cube.cend();
+            }
+        };
+
+        using CubeMap = std::map<Cube, Cube>;
+
+        [[nodiscard]] auto nInputs() const -> std::size_t {
+            if (cubeMap.empty()) {
+                return 0U;
+            }
+            return cubeMap.begin()->first.size();
+        }
+
+        [[nodiscard]] auto nOutputs() const -> std::size_t {
+            if (cubeMap.empty()) {
+                return 0U;
+            }
+            return cubeMap.begin()->second.size();
+        }
+
+        auto insert(const Cube& input, const Cube& output) -> void {
+            assert(cubeMap.empty() || (input.size() == nInputs() && output.size() == nOutputs()));
+            cubeMap.try_emplace(input, output);
+        }
+        auto insert(Cube&& input, Cube&& output) -> void {
+            assert(cubeMap.empty() || (input.size() == nInputs() && output.size() == nOutputs()));
+            cubeMap.try_emplace(std::move(input), std::move(output));
+        }
+
+        auto clear() -> void {
+            cubeMap.clear();
+        }
+
+        [[nodiscard]] const CubeMap& ioCube() const {
+            return cubeMap;
+        }
+
+        auto extend() -> void;
+
+        auto encodeHuffman() -> void;
+
+        auto augmentWithConstants() -> void;
+
+        auto buildDD(std::unique_ptr<dd::Package<>>& dd) const -> dd::mEdge;
+
+    private:
+        CubeMap cubeMap{};
+
+        struct MinHeapNode {
+            Cube data;
+
+            std::size_t freq{};
+
+            std::shared_ptr<MinHeapNode> left{};
+            std::shared_ptr<MinHeapNode> right{};
+
+            MinHeapNode(Cube data, const std::size_t freq):
+                data(std::move(data)), freq(freq) {}
+
+            auto operator>(const MinHeapNode& other) const -> bool {
+                return freq > other.freq;
+            }
+
+            auto traverse(Cube&& encodedCube, CubeMap& encoding) const -> void {
+                // leaf node -> add encoding
+                if (!data.empty()) {
+                    encoding.try_emplace(data, std::move(encodedCube));
+                    return;
+                }
+
+                // non-leaf node -> traverse left and right subtree
+                if (left) {
+                    left->traverse(encodedCube.appendZero(), encoding);
+                }
+                if (right) {
+                    right->traverse(encodedCube.appendOne(), encoding);
+                }
+            }
+        };
+    };
+} // namespace syrec

pyproject.toml

@@ -1,6 +1,6 @@
 [build-system]
 requires = [
-    "setuptools>=45",
+    "setuptools<64",
     "setuptools_scm>=6.4",
     "wheel>=0.37",
     "ninja>=1.10; sys_platform != 'win32'",

src/CMakeLists.txt

@@ -8,6 +8,9 @@ add_library(${PROJECT_NAME}
             ${CMAKE_CURRENT_SOURCE_DIR}/core/syrec/parser.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/core/syrec/program.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/core/syrec/variable.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/core/truthTable/truth_table.cpp
+			${CMAKE_CURRENT_SOURCE_DIR}/core/truthTable/dd_synthesis.cpp
+			${CMAKE_CURRENT_SOURCE_DIR}/core/truthTable/pla_parser.cpp
 
             ${${PROJECT_NAME}_SOURCE_DIR}/include/core/gate.hpp
             ${${PROJECT_NAME}_SOURCE_DIR}/include/core/circuit.hpp
@@ -19,7 +22,10 @@ add_library(${PROJECT_NAME}
             ${${PROJECT_NAME}_SOURCE_DIR}/include/core/syrec/program.hpp
             ${${PROJECT_NAME}_SOURCE_DIR}/include/core/syrec/statement.hpp
             ${${PROJECT_NAME}_SOURCE_DIR}/include/core/syrec/variable.hpp
-            ${${PROJECT_NAME}_SOURCE_DIR}/include/core/utils/timer.hpp)
+            ${${PROJECT_NAME}_SOURCE_DIR}/include/core/utils/timer.hpp
+            ${${PROJECT_NAME}_SOURCE_DIR}/include/core/truthTable/truth_table.hpp
+			${${PROJECT_NAME}_SOURCE_DIR}/include/core/truthTable/dd_synthesis.hpp
+			${${PROJECT_NAME}_SOURCE_DIR}/include/core/truthTable/pla_parser.hpp)
 
 # set include directories
 target_include_directories(${PROJECT_NAME} PUBLIC $<BUILD_INTERFACE:${${PROJECT_NAME}_SOURCE_DIR}/include>)