Merge branch 'feature/MIR-678' into develop

Author: pmaciel

src/mir/method/WeightMatrix.cc

@@ -13,6 +13,8 @@
 #include "mir/method/WeightMatrix.h"
 
 #include <cmath>
+#include <sstream>
+#include <unordered_set>
 
 #include "eckit/types/FloatCompare.h"
 
@@ -101,54 +103,68 @@ void WeightMatrix::cleanup(const double& pruneEpsilon) {
 
 
 void WeightMatrix::validate(const char* when) const {
-    constexpr size_t Nerrors = 50;
-    constexpr size_t Nvalues = 10;
+    constexpr size_t Nerrors = 10;
+    size_t errors            = 0;
 
-    size_t errors = 0;
+    std::ostringstream what;
+    const char* sep = "";
 
+    // check for weights out of bounds 0 <= W(i,j) <= 1, sum(W(i,:))=(0,1), and dulplicate column indices
     for (Size r = 0; r < rows(); r++) {
-
-        // check for W(i,j)<0, or W(i,j)>1, or sum(W(i,:))!=(0,1)
-        double sum = 0.;
-        bool ok    = true;
-
-        for (const_iterator it = begin(r); it != end(r); ++it) {
-            double a = *it;
-            ok &= eckit::types::is_approximately_greater_or_equal(a, 0.) &&
-                  eckit::types::is_approximately_greater_or_equal(1., a);
+        Scalar sum = 0.;
+        std::unordered_set<Size> cols;
+
+        bool check_bounds        = true;
+        bool check_no_duplicates = true;
+        for (auto it = begin(r); it != end(r); ++it) {
+            auto a = *it;
+            check_bounds &= eckit::types::is_approximately_greater_or_equal(a, 0.) &&
+                            eckit::types::is_approximately_greater_or_equal(1., a);
             sum += a;
-        }
 
-        ok &= (eckit::types::is_approximately_equal(sum, 0.) || eckit::types::is_approximately_equal(sum, 1.));
-        if (ok) {
-            continue;
+            check_no_duplicates &= cols.insert(it.col()).second;
         }
 
-        // log issues, per row
-        if (Log::debug_active()) {
+        auto check_sum = eckit::types::is_approximately_equal(sum, 0.) || eckit::types::is_approximately_equal(sum, 1.);
+
+        if (!check_bounds || !check_sum || !check_no_duplicates) {
             if (errors < Nerrors) {
-                if (errors == 0) {
-                    Log::debug() << "WeightMatrix::validate(" << when << ") failed " << std::endl;
+                what << sep << "row " << r << ": ";
+                const char* s = "";
+
+                if (!check_bounds) {
+                    what << s << "weights out-of-bounds";
+                    s = ", ";
                 }
 
-                Log::debug() << "Row: " << r;
-                size_t n = 0;
-                for (const_iterator it = begin(r); it != end(r); ++it, ++n) {
-                    if (n > Nvalues) {
-                        Log::debug() << " ...";
-                        break;
-                    }
-                    Log::debug() << " [" << *it << "]";
+                if (!check_sum) {
+                    what << s << "weights sum not 0 or 1 (sum=" << sum << ", 1-sum=" << (1 - sum) << ")";
+                    s = ", ";
                 }
 
-                Log::debug() << " sum=" << sum << ", 1-sum " << (1 - sum) << std::endl;
-            }
-            else if (errors == Nerrors) {
-                Log::debug() << "..." << std::endl;
+                if (!check_no_duplicates) {
+                    what << s << "duplicate indices";
+                    s = ", ";
+                }
+
+                what << s << "contents: ";
+                s = "";
+                for (auto it = begin(r); it != end(r); ++it) {
+                    what << s << '(' << it.row() << ',' << it.col() << ',' << *it << ')';
+                    s = ", ";
+                }
             }
+
             errors++;
+            sep = ", ";
         }
     }
+
+    if (errors > 0) {
+        std::ostringstream errors_str;
+        errors_str << Log::Pretty{errors, {"row error"}};
+        throw exception::InvalidWeightMatrix{when, errors_str.str() + ", " + what.str()};
+    }
 }
 
 

src/mir/method/knn/KNearestNeighbours.cc

@@ -162,4 +162,9 @@ void KNearestNeighbours::print(std::ostream& out) const {
 }
 
 
+bool KNearestNeighbours::validateMatrixWeights() const {
+    return distanceWeighting().validateMatrixWeights();
+}
+
+
 }  // namespace mir::method::knn

src/mir/method/knn/KNearestNeighbours.h

@@ -55,6 +55,8 @@ class KNearestNeighbours : public MethodWeighted {
 
     virtual const pick::Pick& pick() const                               = 0;
     virtual const distance::DistanceWeighting& distanceWeighting() const = 0;
+
+    virtual bool validateMatrixWeights() const;
 };
 
 

src/mir/method/knn/distance/DistanceWeighting.cc

@@ -85,4 +85,9 @@ void DistanceWeightingFactory::list(std::ostream& out) {
 }
 
 
+bool DistanceWeighting::validateMatrixWeights() const {
+    return true;
+}
+
+
 }  // namespace mir::method::knn::distance

src/mir/method/knn/distance/DistanceWeighting.h

@@ -47,6 +47,8 @@ class DistanceWeighting {
 
     virtual void hash(eckit::MD5&) const = 0;
 
+    virtual bool validateMatrixWeights() const;
+
 private:
     virtual void json(eckit::JSON&) const   = 0;
     virtual void print(std::ostream&) const = 0;

src/mir/method/knn/distance/PseudoLaplace.cc

@@ -127,6 +127,12 @@ void PseudoLaplace::hash(eckit::MD5& h) const {
 }
 
 
+bool PseudoLaplace::validateMatrixWeights() const {
+    // this method does not produce bounded interpolation weights
+    return false;
+}
+
+
 static const DistanceWeightingBuilder<PseudoLaplace> __distance("pseudo-laplace");
 
 

src/mir/method/knn/distance/PseudoLaplace.h

@@ -28,6 +28,8 @@ struct PseudoLaplace : DistanceWeighting {
     void json(eckit::JSON&) const override;
     void print(std::ostream&) const override;
     void hash(eckit::MD5&) const override;
+
+    bool validateMatrixWeights() const override;
 };
 
 

src/mir/util/Exceptions.h

@@ -55,4 +55,14 @@ class CannotConvert : public eckit::Exception {
 };
 
 
+class InvalidWeightMatrix : public eckit::Exception {
+public:
+    InvalidWeightMatrix(const char* when, const std::string& what) {
+        std::ostringstream os;
+        os << "Invalid weight matrix (" << when << "): " << what;
+        reason(os.str());
+    }
+};
+
+
 }  // namespace mir::exception

tests/unit/CMakeLists.txt

@@ -30,6 +30,7 @@ foreach(_t
     statistics
     style
     vector-space
+    weight_matrix
     wind)
     ecbuild_add_test(
         TARGET            mir_tests_unit_${_t}

tests/unit/weight_matrix.cc

@@ -0,0 +1,108 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+
+#include "eckit/testing/Test.h"
+
+#include "mir/method/WeightMatrix.h"
+#include "mir/util/Exceptions.h"
+
+
+namespace mir::tests::unit {
+
+
+CASE("WeightMatrix::validate") {
+    SECTION("out-of-bounds") {
+        const auto* when{"out-of-bounds"};
+        const std::string what{
+            "Invalid weight matrix (out-of-bounds): 1 row error, "
+            "row 2: weights out-of-bounds, "
+            "weights sum not 0 or 1 (sum=-0.1, 1-sum=1.1), contents: (2,2,-0.1)"};
+
+        method::WeightMatrix W(3, 3);
+        W.setFromTriplets({{0, 0, 1.}, {1, 1, 0.}, {2, 2, -0.1}});
+
+        try {
+            W.validate(when);
+            ASSERT(false);
+        }
+        catch (exception::InvalidWeightMatrix& e) {
+            EXPECT(e.what() == what);
+        }
+    }
+
+
+    SECTION("weights sum") {
+        const auto* when{"weights sum"};
+        const std::string what{
+            "Invalid weight matrix (weights sum): 2 row errors, "
+            "row 1: weights sum not 0 or 1 (sum=0.5, 1-sum=0.5), contents: (1,1,0.5), "
+            "row 2: weights sum not 0 or 1 (sum=0.1, 1-sum=0.9), contents: (2,2,0.1)"};
+
+        method::WeightMatrix W(3, 3);
+        W.setFromTriplets({{0, 0, 1.}, {1, 1, 0.5}, {2, 2, 0.1}});
+
+        try {
+            W.validate(when);
+            ASSERT(false);
+        }
+        catch (exception::InvalidWeightMatrix& e) {
+            EXPECT(e.what() == what);
+        }
+    }
+
+
+    SECTION("duplicate indices") {
+        const auto* when{"duplicate indices"};
+        const std::string what{
+            "Invalid weight matrix (duplicate indices): 1 row error, "
+            "row 1: duplicate indices, contents: (1,1,0.5), (1,1,0.5)"};
+
+        method::WeightMatrix W(3, 3);
+        W.setFromTriplets({{0, 0, 1.}, {1, 1, 0.5}, {1, 1, 0.5}});
+
+        try {
+            W.validate(when);
+            ASSERT(false);
+        }
+        catch (exception::InvalidWeightMatrix& e) {
+            EXPECT(e.what() == what);
+        }
+    }
+
+
+    SECTION("mixed") {
+        const auto* when{"mixed"};
+        const std::string what{
+            "Invalid weight matrix (mixed): 2 row errors, "
+            "row 0: duplicate indices, contents: (0,0,0.5), (0,0,0.5), "
+            "row 1: weights sum not 0 or 1 (sum=0.5, 1-sum=0.5), contents: (1,1,0.5)"};
+
+        method::WeightMatrix W(3, 3);
+        W.setFromTriplets({{0, 0, 0.5}, {0, 0, 0.5}, {1, 1, 0.5}});
+
+        try {
+            W.validate(when);
+            ASSERT(false);
+        }
+        catch (exception::InvalidWeightMatrix& e) {
+            EXPECT(e.what() == what);
+        }
+    }
+}
+
+
+}  // namespace mir::tests::unit
+
+
+int main(int argc, char** argv) {
+    return eckit::testing::run_tests(argc, argv);
+}