[DAPHNE-daphne-eu#768] isNan: elementwise check for NaN elements (dap…

…hne-eu#779)

- This commit introduces the isNan() function to DAPHNE, enabling element-wise NaN checks on matrices and scalars 
- Created an IsNanOp operation in DaphneIR as a subclass of EwUnaryOp (elementwise unary operation) (see src/ir/daphneir/DaphneOps.td).
- Created a DaphneDSL built-in function isNan() and documented it (see src/parser/daphnedsl/DaphneDSLBuiltins.cpp and doc/DaphneDSL/Builtins.md).
- Created a DaphneLib function isNan() for matrices and scalars and documented it (see src/api/python/daphne/operator/nodes/matrix.py, src/api/python/daphne/operator/nodes/scalar.py, and doc/DaphneLib/APIRef.md).
- Created a runtime kernel for isNan() by extending the existing ewUnaryMat and ewUnarySca kernel with a new op code (see src/runtime/local/kernels/EwUnaryMat.h).
- Added unit test cases for the kernel and script-level test cases for DaphneDSL and DaphneLib.
- Remove the remark on missing isNan() in the guidelines on porting from Numpy to DaphneLib (see docs/DaphneLib/Numpy2DaphneLib.py).
- Closes daphne-eu#768.

doc/DaphneDSL/Builtins.md

@@ -143,6 +143,12 @@ The following built-in functions all follow the same scheme:
 | **`floor`** | round down |
 | **`ceil`** | round up |
 
+### Comparison
+
+| function | meaning |
+| ----- | ----- |
+| **`isNan`** | `1` if argument is NaN, `0` otherwise |
+
 ## Elementwise binary
 
 DaphneDSL supports various elementwise binary operations.

doc/DaphneLib/APIRef.md

@@ -87,6 +87,7 @@ In the following, we describe only the latter.
 - **`sinh`**`()`
 - **`cosh`**`()`
 - **`tanh`**`()`
+- **`isNan`**`()`
 
 **Elementwise binary:**
 
@@ -222,6 +223,7 @@ In the following, we describe only the latter.
 - **`sinh`**`()`
 - **`cosh`**`()`
 - **`tanh`**`()`
+- **`isNan`**`()`
 
 **Elementwise binary:**
 

doc/DaphneLib/Numpy2DaphneLib.md

@@ -216,8 +216,6 @@ Porting for other Numpy versions may be possible by following similar lines of t
 
 - `numpy.`**`isnan`**`(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) = <ufunc 'isnan'>`
 
-    *Note: `isNan()` is not supported in DAPHNE yet (see #768).*
-
     *Parameters*
 
     - `x`: supported

src/api/python/daphne/operator/nodes/matrix.py

@@ -192,6 +192,12 @@ def sqrt(self) -> 'OperationNode':
         """
         return Matrix(self.daphne_context,'sqrt', [self])
 
+    def isNan(self) -> 'OperationNode':
+        """Elementwise check for NaN values in this matrix (resulting in 1 if the element is NaN, 0 otherwise).
+        :return: `Matrix` A node representing the isNan operation.
+        """
+        return Matrix(self.daphne_context, 'isNan', [self])
+
     def round(self) -> 'OperationNode':
         return Matrix(self.daphne_context, 'round', [self])
 

src/api/python/daphne/operator/nodes/scalar.py

@@ -185,6 +185,9 @@ def acos(self) -> 'Scalar':
     def atan(self) -> 'Scalar':
         return Scalar(self.daphne_context, 'atan', [self])
 
+    def isNan(self) -> 'Scalar':
+        return Scalar(self.daphne_context, 'isNan', [self])
+
     def pow(self, other) -> 'Scalar':
         return Scalar(self.daphne_context, 'pow', [self, other])
 

src/ir/daphneir/DaphneOps.td

@@ -244,6 +244,12 @@ def Daphne_EwAsinOp : Daphne_EwUnaryOp<"ewAsin", NumScalar, [ValueTypeFromArgsFP
 def Daphne_EwAcosOp : Daphne_EwUnaryOp<"ewAcos", NumScalar, [ValueTypeFromArgsFP]>;
 def Daphne_EwAtanOp : Daphne_EwUnaryOp<"ewAtan", NumScalar, [ValueTypeFromArgsFP]>;
 
+// ----------------------------------------------------------------------------
+// Comparison
+// ----------------------------------------------------------------------------
+
+def Daphne_EwIsNanOp : Daphne_EwUnaryOp<"ewIsnan", NumScalar, [ValueTypeFromFirstArg]>;
+
 // ****************************************************************************
 // Elementwise binary
 // ****************************************************************************

src/parser/daphnedsl/DaphneDSLBuiltins.cpp

@@ -520,6 +520,13 @@ antlrcpp::Any DaphneDSLBuiltins::build(mlir::Location loc, const std::string & f
     if(func == "atan")
         return createUnaryOp<EwAtanOp>(loc, func, args);
 
+    // --------------------------------------------------------------------
+    // Comparison
+    // --------------------------------------------------------------------
+
+    if (func == "isNan")
+        return createUnaryOp<EwIsNanOp>(loc, func, args);
+
     // ********************************************************************
     // Elementwise binary
     // ********************************************************************

src/runtime/local/kernels/EwUnarySca.h

@@ -81,6 +81,8 @@ EwUnaryScaFuncPtr<VTRes, VTArg> getEwUnaryScaFuncPtr(UnaryOpCode opCode) {
         MAKE_CASE(UnaryOpCode::FLOOR)
         MAKE_CASE(UnaryOpCode::CEIL)
         MAKE_CASE(UnaryOpCode::ROUND)
+        // Comparison.
+        MAKE_CASE(UnaryOpCode::ISNAN)
         #undef MAKE_CASE
         default:
             throw std::runtime_error("unknown UnaryOpCode");
@@ -167,6 +169,8 @@ MAKE_EW_UNARY_SCA(UnaryOpCode::TANH, tanh(arg));
 MAKE_EW_UNARY_SCA(UnaryOpCode::FLOOR, floor(arg));
 MAKE_EW_UNARY_SCA(UnaryOpCode::CEIL, std::ceil(arg));
 MAKE_EW_UNARY_SCA(UnaryOpCode::ROUND, round(arg));
+// Comparison.
+MAKE_EW_UNARY_SCA(UnaryOpCode::ISNAN, std::isnan(arg));
 
 #undef MAKE_EW_UNARY_SCA_CLOSED_DOMAIN_ERROR
 #undef MAKE_EW_UNARY_SCA_OPEN_DOMAIN_ERROR

src/runtime/local/kernels/UnaryOpCode.h

@@ -41,6 +41,8 @@ enum class UnaryOpCode {
     FLOOR,
     CEIL,
     ROUND,
+    // Comparison.
+    ISNAN
 };
 
 #endif //SRC_RUNTIME_LOCAL_KERNELS_UNARYOPCODE_H

src/runtime/local/kernels/kernels.json

@@ -2909,7 +2909,7 @@
             [["DenseMatrix", "int64_t"],["DenseMatrix", "int64_t"]]
         ],
         "opCodes": ["MINUS", "SIGN", "SQRT", "EXP", "ABS", "FLOOR", "CEIL", "ROUND", "LN",
-                    "SIN", "COS", "TAN", "ASIN", "ACOS", "ATAN", "SINH", "COSH", "TANH"]
+                    "SIN", "COS", "TAN", "ASIN", "ACOS", "ATAN", "SINH", "COSH", "TANH", "ISNAN"]
     },
     {
         "kernelTemplate": {
@@ -2943,7 +2943,7 @@
             ["int64_t", "int64_t"]
         ],
         "opCodes": ["MINUS", "SIGN", "SQRT", "EXP", "ABS", "FLOOR", "CEIL", "ROUND", "LN",
-                    "SIN", "COS", "TAN", "ASIN", "ACOS", "ATAN", "SINH", "COSH", "TANH"]
+                    "SIN", "COS", "TAN", "ASIN", "ACOS", "ATAN", "SINH", "COSH", "TANH", "ISNAN"]
     },
     {
         "kernelTemplate": {

test/api/cli/operations/OperationsTest.cpp

@@ -43,6 +43,7 @@ MAKE_TEST_CASE("ctable", 1)
 MAKE_TEST_CASE("gemv", 1)
 MAKE_TEST_CASE("idxMax", 1)
 MAKE_TEST_CASE("idxMin", 1)
+MAKE_TEST_CASE("isNan", 1)
 MAKE_TEST_CASE("mean", 1)
 MAKE_TEST_CASE("operator_at", 2)
 MAKE_TEST_CASE("operator_eq", 2)

test/api/cli/operations/isNan_1.daphne

@@ -0,0 +1,4 @@
+print(isNan(3));
+print(isNan(nan));
+X = t([1, nan, 0, inf, 99.9, nan]);
+print(isNan(X));

test/api/cli/operations/isNan_1.txt

@@ -0,0 +1,4 @@
+0
+1
+DenseMatrix(1x6, double)
+0 1 0 0 0 1

test/api/python/matrix_ewunary.daphne

@@ -38,4 +38,7 @@ print(acos(m));
 print(atan(m));
 print(sinh(m));
 print(cosh(m));
-print(tanh(m));
+print(tanh(m));
+
+print(isNan(m));
+print(isNan([nan]));

test/api/python/matrix_ewunary.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 from daphne.context.daphne_context import DaphneContext
+import math
 
 dc = DaphneContext()
 
@@ -42,4 +43,7 @@
 m.atan().print().compute()
 m.sinh().print().compute()
 m.cosh().print().compute()
-m.tanh().print().compute()
+m.tanh().print().compute()
+
+m.isNan().print().compute()
+dc.fill(math.nan, 1, 1).isNan().print().compute()

test/api/python/scalar_ewunary.daphne

@@ -38,4 +38,7 @@ print(acos(s));
 print(atan(s));
 print(sinh(s));
 print(cosh(s));
-print(tanh(s));
+print(tanh(s));
+
+print(isNan(s));
+print(isNan(nan));

test/api/python/scalar_ewunary.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 from daphne.context.daphne_context import DaphneContext
+import math
 
 dc = DaphneContext()
 
@@ -45,4 +46,7 @@
 s.sum().atan().print().compute()
 s.sum().sinh().print().compute()
 s.sum().cosh().print().compute()
-s.sum().tanh().print().compute()
+s.sum().tanh().print().compute()
+
+s.sum().isNan().print().compute()
+dc.fill(math.nan, 1, 1).cbind(dc.fill(1.0, 1, 1)).sum().isNan().print().compute()

test/runtime/local/kernels/EwUnaryMatTest.cpp

@@ -548,6 +548,65 @@ TEMPLATE_PRODUCT_TEST_CASE(TEST_NAME("round, floating-point-specific"), TAG_KERN
     DataObjectFactory::destroy(arg, exp);
 }
 
+// ****************************************************************************
+// Comparison
+// ****************************************************************************
+
+TEMPLATE_PRODUCT_TEST_CASE(TEST_NAME("isNan"), TAG_KERNELS, (DATA_TYPES), (int32_t)) {
+    using DT = TestType;
+
+    auto arg = genGivenVals<DT>(4, {
+        1,
+        0,
+        99,
+        -99, 
+    });
+
+    auto exp = genGivenVals<DT>(4, {
+        0,
+        0,
+        0,
+        0
+    });
+
+    checkEwUnaryMat(UnaryOpCode::ISNAN, arg, exp);
+
+    DataObjectFactory::destroy(arg, exp);
+}
+
+TEMPLATE_PRODUCT_TEST_CASE(TEST_NAME("isNan, floating-point specific"), TAG_KERNELS, (DATA_TYPES), (double)) {
+    using DT = TestType;
+    using VT = typename DT::VT;
+
+    auto arg = genGivenVals<DT>(9, {
+        1,
+        std::numeric_limits<VT>::quiet_NaN(),
+        0,
+        std::numeric_limits<VT>::infinity(),
+        -std::numeric_limits<VT>::infinity(), 
+        99.9,
+        -99.9,
+        std::numeric_limits<VT>::quiet_NaN(),
+        std::numeric_limits<VT>::denorm_min()
+    });
+
+    auto exp = genGivenVals<DT>(9, {
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0
+    });
+
+    checkEwUnaryMat(UnaryOpCode::ISNAN, arg, exp);
+
+    DataObjectFactory::destroy(arg, exp);
+}
+
 // ****************************************************************************
 // Invalid op-code
 // ****************************************************************************
@@ -560,4 +619,4 @@ TEMPLATE_PRODUCT_TEST_CASE(TEST_NAME("some invalid op-code"), TAG_KERNELS, (DATA
     CHECK_THROWS(ewUnaryMat<DT, DT>(static_cast<UnaryOpCode>(999), exp, arg, nullptr));
 
     DataObjectFactory::destroy(arg);
-}
+}

test/runtime/local/kernels/EwUnaryScaTest.cpp

@@ -236,6 +236,30 @@ TEMPLATE_TEST_CASE(TEST_NAME("round, floating-point-specific"), TAG_KERNELS, FP_
     checkEwUnarySca<UnaryOpCode::ROUND, VT>(-0.5, -1);
 }
 
+// ****************************************************************************
+// Comparison
+// ****************************************************************************
+
+TEMPLATE_TEST_CASE(TEST_NAME("isNan"), TAG_KERNELS, SI_VALUE_TYPES) {
+    using VT = TestType;
+    checkEwUnarySca<UnaryOpCode::ISNAN, VT>(1, 0);
+    checkEwUnarySca<UnaryOpCode::ISNAN, VT>(99, 0);
+    checkEwUnarySca<UnaryOpCode::ISNAN, VT>(-99, 0);
+    checkEwUnarySca<UnaryOpCode::ISNAN, VT>(0, 0);
+}
+
+TEMPLATE_TEST_CASE(TEST_NAME("isNan, floating-point-specific"), TAG_KERNELS, FP_VALUE_TYPES) {
+    using VT = TestType;
+    checkEwUnarySca<UnaryOpCode::ISNAN, VT>(1, 0);
+    checkEwUnarySca<UnaryOpCode::ISNAN, VT>(std::numeric_limits<VT>::quiet_NaN(), 1);
+    checkEwUnarySca<UnaryOpCode::ISNAN, VT>(std::numeric_limits<VT>::infinity(), 0);
+    checkEwUnarySca<UnaryOpCode::ISNAN, VT>(-std::numeric_limits<VT>::infinity(), 0);
+    checkEwUnarySca<UnaryOpCode::ISNAN, VT>(99.9, 0);
+    checkEwUnarySca<UnaryOpCode::ISNAN, VT>(-99.9, 0);
+    checkEwUnarySca<UnaryOpCode::ISNAN, VT>(0, 0);
+    checkEwUnarySca<UnaryOpCode::ISNAN, VT>(std::numeric_limits<VT>::denorm_min(), 0);
+}
+
 // ****************************************************************************
 // Invalid op-code
 // ****************************************************************************