Adds IsNan and IsInf Operators

docs_input/api/logic/truth/isinf.rst

@@ -0,0 +1,17 @@
+.. _isinf_func:
+
+isinf
+=====
+
+Returns a truth value if operator value is infinite
+
+.. doxygenfunction:: isinf(Op x)
+
+Examples
+~~~~~~~~
+
+.. literalinclude:: ../../../../test/00_operators/OperatorTests.cu
+   :language: cpp
+   :start-after: example-begin inf-test-1
+   :end-before: example-end inf-test-1
+   :dedent:

docs_input/api/logic/truth/isnan.rst

@@ -0,0 +1,17 @@
+.. _isnan_func:
+
+isnan
+=====
+
+Returns a truth value if operator value is NaN
+
+.. doxygenfunction:: isnan(Op t)
+
+Examples
+~~~~~~~~
+
+.. literalinclude:: ../../../../test/00_operators/OperatorTests.cu
+   :language: cpp
+   :start-after: example-begin nan-test-1
+   :end-before: example-end nan-test-1
+   :dedent:

include/matx/operators/scalar_ops.h

@@ -662,6 +662,60 @@ template <typename T1> struct NotF {
 };
 template <typename T1> using NotOp = UnOp<T1, NotF<T1>>;
 
+template <typename T>
+static __MATX_INLINE__ __MATX_HOST__ __MATX_DEVICE__ auto _internal_isnan(T v1)
+{
+  using conversionType = typename matx::detail::value_promote_t<T>;  
+  if constexpr(!std::is_floating_point_v<conversionType>) {
+    return false;
+  } 
+
+  using castType = matx::detail::matx_convert_complex_type<T>;
+  if constexpr(is_complex_v<T>) {
+    return cuda::std::isnan(static_cast<typename castType::value_type>(v1.real())) || cuda::std::isnan(static_cast<typename castType::value_type>(v1.imag()));
+  } else {
+    return cuda::std::isnan(static_cast<castType>(v1));
+  }
+
+  return false;  
+}
+template <typename T>
+struct IsNan {
+  static __MATX_INLINE__ std::string str() { return "isnan"; }
+  static __MATX_INLINE__ __MATX_HOST__ __MATX_DEVICE__ auto op(T v1)
+  {
+    return _internal_isnan(v1);
+  }
+};
+template <typename T> using IsNanOp = UnOp<T, IsNan<T>>;   
+
+template <typename T>
+static __MATX_INLINE__ __MATX_HOST__ __MATX_DEVICE__ auto _internal_isinf(T v1)
+{
+  using conversionType = typename matx::detail::value_promote_t<T>;  
+  if constexpr(!std::is_floating_point_v<conversionType>) {
+    return false;
+  } 
+
+  using castType = matx::detail::matx_convert_complex_type<T>;
+  if constexpr(is_complex_v<T>) {
+    return cuda::std::isinf(static_cast<typename castType::value_type>(v1.real())) || cuda::std::isinf(static_cast<typename castType::value_type>(v1.imag()));
+  } else {
+    return cuda::std::isinf(static_cast<castType>(v1));
+  }
+
+  return false;  
+}
+template <typename T>
+struct IsInf {
+  static __MATX_INLINE__ std::string str() { return "isinf"; }
+  static __MATX_INLINE__ __MATX_HOST__ __MATX_DEVICE__ auto op(T v1)
+  {
+    return _internal_isinf(v1);
+  }
+};
+template <typename T> using IsInfOp = UnOp<T, IsInf<T>>;   
+
 template <typename T1, typename T2> struct AndF {
   static std::string str(const std::string &str1, const std::string &str2) { return "(" + str1 + "&" + str2 + ")"; }
 

include/matx/operators/unary_operators.h

@@ -336,6 +336,21 @@ namespace matx
  *   Input operator
  */
   Op imag(Op t) {}  
+
+ /**
+ * Returns a truth value if operator value is NaN
+ * @param t
+ *   Input operator
+ */
+  Op isnan(Op t) {}  
+
+ /**
+ * Returns a truth value if operator value is infinite
+  * @param x
+ *   Input operator
+ */
+  Op isinf( Op x) {}  
+
 #else
   DEFINE_UNARY_OP(sqrt, detail::SqrtOp);
   DEFINE_UNARY_OP(exp, detail::ExpOp);
@@ -401,6 +416,8 @@ namespace matx
 #endif
   DEFINE_UNARY_OP(imag, detail::ImagOp);  
   DEFINE_UNARY_OP(operator-, detail::SubNegOp );
+  DEFINE_UNARY_OP(isnan, detail::IsNanOp);
+  DEFINE_UNARY_OP(isinf, detail::IsInfOp);
 #endif
 
 } // end namespace matx

test/00_operators/OperatorTests.cu

@@ -1846,6 +1846,47 @@ TYPED_TEST(OperatorTestsNumericAllExecs, OperatorFuncs)
   res = c * c * (c + c) / c + three;
   EXPECT_TRUE(MatXUtils::MatXTypeCompare(tov0(), res, 0.07));
 
+  auto nan = make_tensor<TestType>({});
+  using conversionType = typename matx::detail::value_promote_t<TestType>;  
+  if constexpr(matx::is_complex_v<TestType>) {    
+    nan() = TestType(std::numeric_limits<conversionType>::quiet_NaN());
+  } else {
+    nan() = std::numeric_limits<conversionType>::quiet_NaN();
+  }
+  auto tob = make_tensor<bool>({});
+  // example-begin nan-test-1
+  (tob = matx::isnan(nan)).run(); 
+  // example-end nan-test-1
+  cudaDeviceSynchronize();  
+  EXPECT_TRUE(MatXUtils::MatXTypeCompare(tob(), std::is_floating_point_v<conversionType> ? true : false));
+
+  auto notnanorinf = make_tensor<TestType>({});
+  if constexpr(matx::is_complex_v<TestType>) {    
+    notnanorinf() = TestType(0);
+  } else {
+    notnanorinf() = 0;
+  }  
+  (tob = matx::isnan(notnanorinf)).run();
+  cudaDeviceSynchronize();  
+  EXPECT_TRUE(MatXUtils::MatXTypeCompare(tob(), false));
+
+  auto inf = make_tensor<TestType>({});
+  using conversionType = typename matx::detail::value_promote_t<TestType>;  
+  if constexpr(matx::is_complex_v<TestType>) {    
+    inf() = TestType(std::numeric_limits<conversionType>::infinity());
+  } else {
+    inf() = std::numeric_limits<conversionType>::infinity();
+  }  
+  // example-begin inf-test-1
+  (tob = matx::isinf(inf)).run(); 
+  // example-end inf-test-1
+  cudaDeviceSynchronize();  
+  EXPECT_TRUE(MatXUtils::MatXTypeCompare(tob(), std::is_floating_point_v<conversionType> ? true : false));
+
+  (tob = matx::isinf(notnanorinf)).run();
+  cudaDeviceSynchronize();  
+  EXPECT_TRUE(MatXUtils::MatXTypeCompare(tob(), false));
+
   MATX_EXIT_HANDLER();
 }