Minor improvements.

- Renamed the new category of unary ops to "Comparison".
- Removed special floating-point values like nan and inf from test cases with integer value types.
- Removed comment on missing isNan() from guidelines on porting from Numpy to DaphneLib.
- Some more minor changes.

doc/DaphneDSL/Builtins.md

@@ -143,11 +143,11 @@ The following built-in functions all follow the same scheme:
 | **`floor`** | round down |
 | **`ceil`** | round up |
 
-### Other Utilities
+### Comparison
 
 | function | meaning |
-| ----- | -------------------------------------- |
-|**`isNan`**| returns 1 if argument is nan, 0 otherwise |
+| ----- | ----- |
+| **`isNan`** | `1` if argument is NaN, `0` otherwise |
 
 ## Elementwise binary
 

doc/DaphneLib/APIRef.md

@@ -223,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

@@ -193,10 +193,10 @@ def sqrt(self) -> 'OperationNode':
         return Matrix(self.daphne_context,'sqrt', [self])
 
     def isNan(self) -> 'OperationNode':
-        """Checks if argument is of type Nan. Returns 1 if argument is Nan, 0 otherwise.
-        :return: `Matrix` representing operation
+        """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])
+        return Matrix(self.daphne_context, 'isNan', [self])
 
     def round(self) -> 'OperationNode':
         return Matrix(self.daphne_context, 'round', [self])

src/ir/daphneir/DaphneOps.td

@@ -215,7 +215,6 @@ def Daphne_EwSignOp : Daphne_EwUnaryOp<"ewSign", NumScalar, [ValueTypeFromFirstA
 def Daphne_EwExpOp : Daphne_EwUnaryOp<"ewExp", NumScalar, [ValueTypeFromArgsFP]>;
 def Daphne_EwLnOp : Daphne_EwUnaryOp<"ewLn", NumScalar, [ValueTypeFromArgsFP]>;
 def Daphne_EwSqrtOp : Daphne_EwUnaryOp<"ewSqrt", NumScalar, [ValueTypeFromArgsFP, DeclareOpInterfaceMethods<VectorizableOpInterface>]>;
-def Daphne_EwIsNanOp : Daphne_EwUnaryOp<"ewIsnan", NumScalar, [ValueTypeFromFirstArg]>;
 
 // ----------------------------------------------------------------------------
 // Logical
@@ -245,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

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

src/runtime/local/kernels/EwUnarySca.h

@@ -81,7 +81,7 @@ EwUnaryScaFuncPtr<VTRes, VTArg> getEwUnaryScaFuncPtr(UnaryOpCode opCode) {
         MAKE_CASE(UnaryOpCode::FLOOR)
         MAKE_CASE(UnaryOpCode::CEIL)
         MAKE_CASE(UnaryOpCode::ROUND)
-        // Other utilities
+        // Comparison.
         MAKE_CASE(UnaryOpCode::ISNAN)
         #undef MAKE_CASE
         default:
@@ -169,7 +169,7 @@ 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));
-// Other Utilities
+// Comparison.
 MAKE_EW_UNARY_SCA(UnaryOpCode::ISNAN, std::isnan(arg));
 
 #undef MAKE_EW_UNARY_SCA_CLOSED_DOMAIN_ERROR

src/runtime/local/kernels/UnaryOpCode.h

@@ -41,7 +41,7 @@ enum class UnaryOpCode {
     FLOOR,
     CEIL,
     ROUND,
-    // Other Utilities
+    // Comparison.
     ISNAN
 };
 

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)
@@ -58,5 +59,4 @@ MAKE_TEST_CASE("seq", 2)
 MAKE_TEST_CASE("solve", 1)
 MAKE_TEST_CASE("sqrt", 1)
 MAKE_TEST_CASE("sum", 1)
-MAKE_TEST_CASE("syrk", 1)
-MAKE_TEST_CASE("isNan", 1)
+MAKE_TEST_CASE("syrk", 1)

test/api/python/matrix_ewunary.daphne

@@ -39,4 +39,6 @@ print(atan(m));
 print(sinh(m));
 print(cosh(m));
 print(tanh(m));
-print(isNan(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()
 
@@ -43,4 +44,6 @@
 m.sinh().print().compute()
 m.cosh().print().compute()
 m.tanh().print().compute()
-m.isNan().print().compute()
+
+m.isNan().print().compute()
+dc.fill(math.nan, 1, 1).isNan().print().compute()

test/api/python/scalar_ewunary.daphne

@@ -39,4 +39,6 @@ print(atan(s));
 print(sinh(s));
 print(cosh(s));
 print(tanh(s));
-print(isNan(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()
 
@@ -46,4 +47,6 @@
 s.sum().sinh().print().compute()
 s.sum().cosh().print().compute()
 s.sum().tanh().print().compute()
-s.sum().isNan().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

@@ -549,27 +549,20 @@ TEMPLATE_PRODUCT_TEST_CASE(TEST_NAME("round, floating-point-specific"), TAG_KERN
 }
 
 // ****************************************************************************
-// Other Utilities
+// Comparison
 // ****************************************************************************
 
 TEMPLATE_PRODUCT_TEST_CASE(TEST_NAME("isNan"), TAG_KERNELS, (DATA_TYPES), (int32_t)) {
     using DT = TestType;
-    using VT = typename DT::VT;
 
-    auto arg = genGivenVals<DT>(7, {
+    auto arg = genGivenVals<DT>(4, {
         1,
-        std::numeric_limits<VT>::quiet_NaN(),
         0,
-        std::numeric_limits<VT>::infinity(),
-        -std::numeric_limits<VT>::infinity(),
         99,
         -99, 
     });
 
-    auto exp = genGivenVals<DT>(7, {
-        0,
-        0,
-        0,
+    auto exp = genGivenVals<DT>(4, {
         0,
         0,
         0,

test/runtime/local/kernels/EwUnaryScaTest.cpp

@@ -237,18 +237,15 @@ TEMPLATE_TEST_CASE(TEST_NAME("round, floating-point-specific"), TAG_KERNELS, FP_
 }
 
 // ****************************************************************************
-// Other Utilities
+// 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>(std::numeric_limits<VT>::quiet_NaN(), 0);
-    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, 0);
     checkEwUnarySca<UnaryOpCode::ISNAN, VT>(-99, 0);
     checkEwUnarySca<UnaryOpCode::ISNAN, VT>(0, 0);
-    checkEwUnarySca<UnaryOpCode::ISNAN, VT>(std::numeric_limits<VT>::denorm_min(), 0);
 }
 
 TEMPLATE_TEST_CASE(TEST_NAME("isNan, floating-point-specific"), TAG_KERNELS, FP_VALUE_TYPES) {