17.04.28 15:23 - Some fixes

Author: Владимир Северов

M3-LW-1/M3-LW-1/BooleanFunction.cpp

@@ -301,7 +301,7 @@ BooleanFunction BooleanFunction::operator()(const std::vector<BooleanFunction>&
 }
 /**/
 
-// ВАРИАНТ 2. Функция от векторов значений
+/*/ ВАРИАНТ 2. Функция от векторов значений
 BooleanFunction BooleanFunction::operator()(const std::vector<BooleanFunction>& fs) const
 {
     if (fs.size() != dimension()) {
@@ -334,6 +334,37 @@ BooleanFunction BooleanFunction::operator()(const std::vector<BooleanFunction>&
 }
 /**/
 
+BooleanFunction BooleanFunction::operator()(const std::vector<BooleanFunction>& fs) const
+{
+    if (fs.size() != dimension()) {
+        throw IncorrectLengthException();
+    }
+    if (fs.size() == 0) {
+        return BooleanFunction();
+    }
+
+    size_type d = 0;
+    for (BooleanFunction const& f : fs) {
+        if (f.dimension() > d) {
+            d = f.dimension();
+        }
+    }
+
+    BooleanFunction result(d);
+
+    for (size_type i = 0; i < result.func_.size(); ++i) {
+        std::vector<bool> vars;
+        for (BooleanFunction const& f : fs) {
+            vars.push_back(f.func_[i % f.size()]);
+        }
+        result.func_[i] = (*this)(vars);
+    }
+
+    //result.func_ = ReduceFunc_(result.func_);
+
+    return result;
+}
+
 BooleanFunction BooleanFunction::operator()(const std::initializer_list<BooleanFunction> fs) const
 {
     if (fs.size() != dimension()) {
@@ -360,7 +391,7 @@ BooleanFunction BooleanFunction::operator()(const std::initializer_list<BooleanF
         result.func_[i] = (*this)(vars);
     }
 
-    result.func_ = ReduceFunc_(result.func_);
+    //result.func_ = ReduceFunc_(result.func_);
 
     return result;
 }
@@ -469,22 +500,22 @@ std::vector<BooleanFunction::value_type> BooleanFunction::anf() const
     return result;
 }
 
-std::vector<BooleanFunction::value_type> BooleanFunction::ReduceFunc_(std::vector<value_type> const& func)
+void BooleanFunction::ReduceFunc()
 {
-    size_type dim = static_cast<size_type>(log2(func.size()));
+    size_type dim = static_cast<size_type>(log2(func_.size()));
 
     std::vector<bool> isEssential(dim, false);
 
     for (size_type j = 0; j < dim; ++j) {
         size_type s = static_cast<size_type>(pow(2, j)); // Размер половины участка
-        size_type c = static_cast<size_type>(func.size() / (s * 2)); // Количество пар
+        size_type c = static_cast<size_type>(func_.size() / (s * 2)); // Количество пар
 
         for (size_type k = 0; k < c; ++k) {
             if (isEssential[j]) {
                 break;
             }
             for (size_type i = 2 * s * k; i < 2 * s * k + s; ++i) {
-                if (func[i] != func[i + s]) {
+                if (func_[i] != func_[i + s]) {
                     isEssential[j] = true;
                     break;
                 }
@@ -500,12 +531,12 @@ std::vector<BooleanFunction::value_type> BooleanFunction::ReduceFunc_(std::vecto
     }
 
     if (dim != newDim) {
-        std::vector<bool> isResValue(func.size(), true);
+        std::vector<bool> isResValue(func_.size(), true);
 
         for (size_type j = 0; j < dim; ++j) {
             if (!isEssential[j]) {
                 size_type s = static_cast<size_type>(pow(2, j)); // Размер половины участка
-                size_type c = static_cast<size_type>(func.size() / (s * 2)); // Количество пар
+                size_type c = static_cast<size_type>(func_.size() / (s * 2)); // Количество пар
 
                 for (size_type k = 0; k < c; ++k) {
                     for (size_type i = 2 * s * k + s; i < 2 * s * k + 2 * s; ++i) {
@@ -517,18 +548,14 @@ std::vector<BooleanFunction::value_type> BooleanFunction::ReduceFunc_(std::vecto
 
         std::vector<value_type> result;
 
-        for (size_type i = 0; i < func.size(); ++i) {
+        for (size_type i = 0; i < func_.size(); ++i) {
             if (isResValue[i]) {
-                result.push_back(func[i]);
+                result.push_back(func_[i]);
             }
         }
 
-        return result;
-    }
-    else {
-        return func;
+        func_ = result;
     }
-
 }
 
 std::string get_polynom(const BooleanFunction& rhs)

M3-LW-1/M3-LW-1/BooleanFunction.h

@@ -136,7 +136,7 @@ class BooleanFunction
     BooleanFunction operator()(const std::initializer_list<BooleanFunction> fs) const;
 
     bool is_monotone() const;
-    bool is_symmetric() const;
+    bool is_symmetric() const; /* БОНУС */
     bool is_self_dual() const;
     bool is_linear() const;
     bool is_T1() const;
@@ -149,10 +149,11 @@ class BooleanFunction
     // Возвращает АНФ функции
     std::vector<value_type> anf() const;
 
+    // Удаляет фиктивные переменные
+    void ReduceFunc(); /* БОНУС */
+
 private:
     std::vector<value_type> func_;
-
-    static std::vector<value_type> ReduceFunc_(std::vector<value_type> const& func);
 };
 
 // пусть BooleanFunction представляет из себя функцию "01110000"

M3-LW-1/M3-LW-1/Source.cpp

@@ -533,12 +533,10 @@ void test_combo()
     assert(!coef[2]);
     assert(coef[4 + 1]); // x0y
     assert(coef[4 + 2]); // x1y
-    /*/ Единственный неработающий тест
     assert(coef[16 + 8 + 1]);  // z0z1x0
     assert(coef[16 + 8 + 2]); // z0z1x0
     assert(coef[16 + 8 + 4]);  // z0z1y
-    assert(!coef[63]);
-    /**/
+    assert(!coef[31]);
 }
 
 void test_combo2()
@@ -561,6 +559,15 @@ void test_combo2()
     assert(test.weight() == 0);
 }
 
+void test_bonus()
+{
+    BooleanFunction x = BooleanFunction::var(2, 5);
+    assert(get_polynom(x) == "x2");
+    x.ReduceFunc();
+    assert(get_polynom(x) == "x0");
+    assert(x.is_symmetric());
+}
+
 int main()
 {
     RUN_TEST(test_ctor0, "successed");
@@ -596,5 +603,8 @@ int main()
     RUN_TEST(test_combo, "successed");
     RUN_TEST(test_combo2, "successed");
 
+    /* Тест бонусных функций */
+    RUN_TEST(test_bonus, "successed");
+
     system("pause");
 }