1 files changed, 125 insertions, 0 deletions
diff --git a/fuzzylite/test/term/DiscreteTest.cpp b/fuzzylite/test/term/DiscreteTest.cpp
new file mode 100644
index 0000000..2fb32aa
--- /dev/null
+++ b/fuzzylite/test/term/DiscreteTest.cpp
@@ -0,0 +1,125 @@
+/*
+ fuzzylite (R), a fuzzy logic control library in C++.
+ Copyright (C) 2010-2017 FuzzyLite Limited. All rights reserved.
+ Author: Juan Rada-Vilela, Ph.D. <jcrada@fuzzylite.com>
+
+ This file is part of fuzzylite.
+
+ fuzzylite is free software: you can redistribute it and/or modify it under
+ the terms of the FuzzyLite License included with the software.
+
+ You should have received a copy of the FuzzyLite License along with
+ fuzzylite. If not, see <http://www.fuzzylite.com/license/>.
+
+ fuzzylite is a registered trademark of FuzzyLite Limited.
+ */
+
+#include "test/catch.hpp"
+#include "fl/Headers.h"
+
+namespace fl {
+
+    /**
+     * Tests: term/Discrete
+     *
+     * @author Juan Rada-Vilela, Ph.D.
+     *
+     */
+
+    TEST_CASE("discrete finds elements using binary search", "[term][discrete]") {
+        fuzzylite::setLogging(true);
+        fuzzylite::setDebugging(false);
+        Rectangle rectangle("rectangle", 0, 1);
+        FL_unique_ptr<Discrete> discrete(Discrete::discretize(&rectangle, rectangle.getStart(), rectangle.getEnd(), 10));
+        FL_LOG(discrete->toString());
+
+        CHECK(discrete->membership(.25) == 1.0);
+        CHECK(discrete->membership(0.0) == 1.0);
+        CHECK(discrete->membership(-1.0) == 1.0);
+        CHECK(discrete->membership(1.0) == 1.0);
+        CHECK(discrete->membership(2.0) == 1.0);
+        CHECK(Op::isNaN(discrete->membership(fl::nan)));
+        CHECK(discrete->membership(fl::inf) == 1.0);
+        CHECK(discrete->membership(-fl::inf) == 1.0);
+    }
+
+    TEST_CASE("discrete still finds elements using binary search", "[term][discrete]") {
+        fuzzylite::setLogging(true);
+        fuzzylite::setDebugging(false);
+        Triangle triangle("triangle", 0, 1);
+        FL_unique_ptr<Discrete> discrete(Discrete::discretize(&triangle, triangle.getVertexA(), triangle.getVertexC(), 100));
+        FL_LOG(discrete->toString());
+        for (int i = 0; i < 200; ++i) {
+            scalar x = Op::scale(i, 0, 200, -1, 1);
+            if (not Op::isEq(triangle.membership(x), discrete->membership(x))) {
+                fuzzylite::setDebugging(true);
+                CHECK(Op::isEq(triangle.membership(x), discrete->membership(x)));
+                fuzzylite::setDebugging(false);
+            }
+        }
+    }
+
+    TEST_CASE("discrete finds all elements using binary search", "[term][discrete]") {
+        fuzzylite::setLogging(true);
+        fuzzylite::setDebugging(false);
+        scalar min = -1.0;
+        scalar max = 1.0;
+        scalar range = max - min;
+        scalar mean = 0.5 * (max + min);
+
+
+        std::vector<Term*> terms;
+        terms.push_back(new Triangle("triangle", min, mean, max));
+        terms.push_back(new Trapezoid("trapezoid", min, min + .25 * range, min + .75 * range, max));
+        terms.push_back(new Rectangle("rectangle", min, max));
+        terms.push_back(new Bell("bell", mean, range / 4, 3.0));
+        terms.push_back(new Cosine("cosine", mean, range));
+        terms.push_back(new Gaussian("gaussian", mean, range / 4));
+        terms.push_back(new GaussianProduct("gaussianProduct", mean, range / 4, mean, range / 4));
+        terms.push_back(new PiShape("piShape", min, mean, mean, max));
+        terms.push_back(new SigmoidDifference("sigmoidDifference", min + .25 * range, 20 / range, 20 / range, max - .25 * range));
+        terms.push_back(new SigmoidProduct("sigmoidProduct", min + .25 * range, 20 / range, 20 / range, max - .25 * range));
+        terms.push_back(new Spike("spike", mean, range));
+
+        terms.push_back(new Binary("binary", min, max));
+        terms.push_back(new Concave("concave", mean, max));
+        terms.push_back(new Ramp("ramp", min, max));
+        terms.push_back(new Sigmoid("sigmoid", mean, 20 / range));
+        terms.push_back(new SShape("sshape", min, max));
+        terms.push_back(new ZShape("zshape", min, max));
+
+        for (std::size_t t = 0; t < terms.size(); ++t) {
+            Term* term = terms.at(t);
+            std::vector<Discrete::Pair> pairs;
+            srand(0);
+            for (int i = 0; i < 1000; ++i) {
+                int randomX = std::rand();
+                scalar x = Op::scale(randomX % 100, 0, 100, -1, 1);
+                pairs.push_back(Discrete::Pair(x, term->membership(x)));
+            }
+            Discrete::sort(pairs);
+
+            Discrete discrete("discrete", pairs);
+            for (std::size_t i = 0; i < pairs.size(); ++i) {
+                Discrete::Pair pair = pairs.at(i);
+                scalar x = pair.first;
+                if (not Op::isEq(discrete.membership(x), term->membership(x))) {
+                    fuzzylite::setDebugging(true);
+                    CHECK(discrete.membership(x) == term->membership(x));
+                    fuzzylite::setDebugging(false);
+                }
+            }
+            for (int i = 0 ; i < 100 ; i++) {
+                scalar x = Op::scale(i, 0, 100, -1, 1);
+                if (not Op::isEq(discrete.membership(x), term->membership(x))) {
+                    fuzzylite::setDebugging(true);
+                    CHECK(discrete.membership(x) == term->membership(x));
+                    fuzzylite::setDebugging(false);
+                }
+            }
+        }
+        for (std::size_t i = 0 ; i < terms.size(); ++i){
+            delete terms.at(i);
+        }
+    }
+}