Convert dt.isna() to FExpr

docs/api/dt/isna.rst

@@ -0,0 +1,50 @@
+
+.. xfunction:: datatable.isna
+    :src: src/core/expr/fexpr_isna.cc pyfn_isna
+    :tests: tests/math/test-isna.py
+    :cvar: doc_dt_isna
+    :signature: isna(cols)
+
+    Test if the column elements are missing values. 
+
+    Parameters
+    ----------
+    cols: FExpr
+        Input columns.
+
+    return: FExpr
+        f-expression that returns `0` for valid elements and `1` otherwise. 
+        All the resulting columns will have `bool8` stypes 
+        and as many rows/columns as there are in `cols`.
+
+    Examples
+    --------
+
+    .. code-block:: python
+
+        >>> from datatable import dt, f
+        >>> from datetime import datetime
+        >>> DT = dt.Frame({'age': [5.0, 6.0, None],
+        ...                'born': [None,
+        ...                datetime(1939, 5, 27, 0, 0),
+        ...                datetime(1940, 4, 25, 0, 0)],
+        ...                'name': ['Alfred', 'Batman', ''],
+        ...                'toy': [None, 'Batmobile', 'Joker']})
+        >>> DT
+           |     age  born                 name    toy      
+           | float64  time64               str32   str32    
+        -- + -------  -------------------  ------  ---------
+         0 |       5  NA                   Alfred  NA       
+         1 |       6  1939-05-27T00:00:00  Batman  Batmobile
+         2 |      NA  1940-04-25T00:00:00          Joker    
+        [3 rows x 4 columns]
+        >>> DT[:, dt.isna(f[:])]
+           |   age   born   name    toy
+           | bool8  bool8  bool8  bool8
+        -- + -----  -----  -----  -----
+         0 |     0      1      0      1
+         1 |     0      0      0      0
+         2 |     1      0      0      0
+        [3 rows x 4 columns]
+
+

docs/api/fexpr.rst

@@ -63,8 +63,8 @@
           - Remove columns from the ``FExpr``.
 
 
-    Arithmeritc operators
-    ---------------------
+    Arithmetic operators
+    --------------------
 
     .. list-table::
         :widths: auto
@@ -190,6 +190,9 @@
         * - :meth:`.first()`
           - Same as :func:`dt.first()`.
 
+        * - :meth:`.isna()`
+          - Same as :func:`dt.isna()`.
+
         * - :meth:`.last()`
           - Same as :func:`dt.last()`.
 
@@ -320,6 +323,7 @@
     .extend()       <fexpr/extend>
     .fillna()       <fexpr/fillna>
     .first()        <fexpr/first>
+    .isna()         <fexpr/isna>
     .last()         <fexpr/last>
     .len()          <fexpr/len>
     .max()          <fexpr/max>

docs/api/fexpr/isna.rst

@@ -0,0 +1,7 @@
+
+.. xmethod:: datatable.FExpr.isna
+    :src: src/core/expr/fexpr.cc PyFExpr::isna
+    :cvar: doc_FExpr_isna
+    :signature: isna()
+
+    Equivalent to :func:`dt.isna(cols)`.

docs/api/index-api.rst

@@ -179,6 +179,8 @@ Functions
       - Calculate covariance between two columns
     * - :func:`fillna()`
       - Impute missing values
+    * - :func:`isna()`
+      - Test for missing values
     * - :func:`max()`
       - Find the largest element per column
     * - :func:`mean()`
@@ -266,6 +268,7 @@ Other
     init_styles()     <dt/init_styles>
     intersect()       <dt/intersect>
     iread()           <dt/iread>
+    isna()            <dt/isna>
     join()            <dt/join>
     last()            <dt/last>
     max()             <dt/max>

docs/api/math/isna.rst

@@ -1,8 +1,10 @@
 
 .. xfunction:: datatable.math.isna
-    :src: src/core/expr/funary/floating.cc resolve_op_isna
+    :src: src/core/expr/fexpr_isna.cc pyfn_isna
     :tests: tests/math/test-isna.py
-    :cvar: doc_math_isna
-    :signature: isna(x)
+    :cvar: doc_dt_isna
+    :signature: isna(cols)
+
+    Same as :func:`dt.isna()`.
+
 
-    Returns `True` if the argument is NA, and `False` otherwise.

src/core/column/isna.h

@@ -21,6 +21,7 @@
 //------------------------------------------------------------------------------
 #ifndef dt_COLUMN_ISNA_h
 #define dt_COLUMN_ISNA_h
+#include "column/const.h"
 #include "column/virtual.h"
 #include "stype.h"
 namespace dt {
@@ -62,7 +63,24 @@ class Isna_ColumnImpl : public Virtual_ColumnImpl {
 };
 
 
-
+static Column make_isna_col(Column&& col) {
+  switch (col.stype()) {
+    case SType::VOID:    return Const_ColumnImpl::make_bool_column(col.nrows(), true);
+    case SType::BOOL:
+    case SType::INT8:    return Column(new Isna_ColumnImpl<int8_t>(std::move(col)));
+    case SType::INT16:   return Column(new Isna_ColumnImpl<int16_t>(std::move(col)));
+    case SType::DATE32:
+    case SType::INT32:   return Column(new Isna_ColumnImpl<int32_t>(std::move(col)));
+    case SType::TIME64:
+    case SType::INT64:   return Column(new Isna_ColumnImpl<int64_t>(std::move(col)));
+    case SType::FLOAT32: return Column(new Isna_ColumnImpl<float>(std::move(col)));
+    case SType::FLOAT64: return Column(new Isna_ColumnImpl<double>(std::move(col)));
+    case SType::STR32:
+    case SType::STR64:   return Column(new Isna_ColumnImpl<CString>(std::move(col)));
+    default: throw RuntimeError();
+  }
+}
 
 }  // namespace dt
 #endif
+

src/core/documentation.h

@@ -45,6 +45,7 @@ extern const char* doc_dt_ifelse;
 extern const char* doc_dt_init_styles;
 extern const char* doc_dt_intersect;
 extern const char* doc_dt_iread;
+extern const char* doc_dt_isna;
 extern const char* doc_dt_join;
 extern const char* doc_dt_last;
 extern const char* doc_dt_max;
@@ -112,7 +113,6 @@ extern const char* doc_math_hypot;
 extern const char* doc_math_isclose;
 extern const char* doc_math_isfinite;
 extern const char* doc_math_isinf;
-extern const char* doc_math_isna;
 extern const char* doc_math_ldexp;
 extern const char* doc_math_lgamma;
 extern const char* doc_math_log10;
@@ -297,6 +297,7 @@ extern const char* doc_FExpr_cumsum;
 extern const char* doc_FExpr_extend;
 extern const char* doc_FExpr_fillna;
 extern const char* doc_FExpr_first;
+extern const char* doc_FExpr_isna;
 extern const char* doc_FExpr_last;
 extern const char* doc_FExpr_max;
 extern const char* doc_FExpr_mean;

src/core/expr/fexpr.cc

@@ -290,7 +290,6 @@ DECLARE_METHOD(&PyFExpr::re_match)
 
 
 
-
 //------------------------------------------------------------------------------
 // Miscellaneous
 //------------------------------------------------------------------------------
@@ -480,6 +479,16 @@ DECLARE_METHOD(&PyFExpr::first)
     ->docs(dt::doc_FExpr_first);
 
 
+oobj PyFExpr::isna(const XArgs&) {
+  auto isnaFn = oobj::import("datatable", "math", "isna");
+  return isnaFn.call({this});
+}
+
+DECLARE_METHOD(&PyFExpr::isna)
+    ->name("isna")
+    ->docs(dt::doc_FExpr_isna);
+
+
 oobj PyFExpr::last(const XArgs&) {
   auto lastFn = oobj::import("datatable", "last");
   return lastFn.call({this});

src/core/expr/fexpr.h

@@ -192,6 +192,7 @@ class PyFExpr : public py::XObject<PyFExpr> {
     py::oobj extend(const py::XArgs&);
     py::oobj fillna(const py::XArgs&);
     py::oobj first(const py::XArgs&);
+    py::oobj isna(const py::XArgs&);
     py::oobj last(const py::XArgs&);
     py::oobj max(const py::XArgs&);
     py::oobj mean(const py::XArgs&);

src/core/expr/fexpr_fillna.cc

@@ -183,26 +183,6 @@ class FExpr_FillNA : public FExpr_Func {
 
       return wf;
     }
-
-
-    static Column make_isna_col(Column&& col) {
-      switch (col.stype()) {
-        case SType::VOID:    return Const_ColumnImpl::make_bool_column(col.nrows(), true);
-        case SType::BOOL:
-        case SType::INT8:    return Column(new Isna_ColumnImpl<int8_t>(std::move(col)));
-        case SType::INT16:   return Column(new Isna_ColumnImpl<int16_t>(std::move(col)));
-        case SType::DATE32:
-        case SType::INT32:   return Column(new Isna_ColumnImpl<int32_t>(std::move(col)));
-        case SType::TIME64:
-        case SType::INT64:   return Column(new Isna_ColumnImpl<int64_t>(std::move(col)));
-        case SType::FLOAT32: return Column(new Isna_ColumnImpl<float>(std::move(col)));
-        case SType::FLOAT64: return Column(new Isna_ColumnImpl<double>(std::move(col)));
-        case SType::STR32:
-        case SType::STR64:   return Column(new Isna_ColumnImpl<CString>(std::move(col)));
-        default: throw RuntimeError();
-      }
-    }
-
 };
 
 
@@ -236,3 +216,4 @@ DECLARE_PYFN(&pyfn_fillna)
 
 
 }}  // dt::expr
+

src/core/expr/fexpr_isna.cc

@@ -0,0 +1,64 @@
+//------------------------------------------------------------------------------
+// Copyright 2022-2023 H2O.ai
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//------------------------------------------------------------------------------
+#include "column/const.h"
+#include "column/isna.h"
+#include "expr/fexpr_column.h"
+#include "documentation.h"
+#include "expr/fexpr_func_unary.h"
+#include "expr/eval_context.h"
+#include "expr/workframe.h"
+#include "python/xargs.h"
+#include "stype.h"
+namespace dt {
+namespace expr {
+
+
+class FExpr_ISNA : public FExpr_FuncUnary {
+  public:
+    using FExpr_FuncUnary::FExpr_FuncUnary;
+
+
+    std::string name() const override {
+      return "isna";
+    }
+
+    Column evaluate1(Column&& col) const override{
+      return make_isna_col(std::move(col));
+    }
+};
+
+
+static py::oobj pyfn_isna(const py::XArgs &args) {
+  auto isna = args[0].to_oobj();
+  return PyFExpr::make(new FExpr_ISNA(as_fexpr(isna)));
+}
+
+DECLARE_PYFN(&pyfn_isna)
+    ->name("isna")
+    ->docs(doc_dt_isna)
+    ->arg_names({"cols"})
+    ->n_positional_args(1)
+    ->n_required_args(1);
+
+
+}}  // dt::expr
+

src/core/expr/fnary/rowcount.cc

@@ -20,11 +20,11 @@
 // IN THE SOFTWARE.
 //------------------------------------------------------------------------------
 #include <algorithm>
+#include "column/isna.h"
 #include "column/const.h"
 #include "column/func_nary.h"
 #include "documentation.h"
 #include "expr/fnary/fnary.h"
-#include "expr/funary/umaker.h"
 #include "python/xargs.h"
 namespace dt {
 namespace expr {
@@ -49,7 +49,6 @@ static bool op_rowcount(size_t i, int32_t* out, const colvec& columns) {
   return true;
 }
 
-
 Column FExpr_RowCount::apply_function(colvec&& columns,
                                       const size_t nrows,
                                       const size_t) const
@@ -59,7 +58,8 @@ Column FExpr_RowCount::apply_function(colvec&& columns,
   }
   for (size_t i = 0; i < columns.size(); ++i) {
     xassert(columns[i].nrows() == nrows);
-    columns[i] = unaryop(Op::ISNA, std::move(columns[i]));
+    Column coli = columns[i];
+    columns[i] = make_isna_col(std::move(coli));
   }
   return Column(new FuncNary_ColumnImpl<int32_t>(
                       std::move(columns), op_rowcount, nrows, SType::INT32));

src/core/expr/funary/floating.cc

@@ -20,7 +20,6 @@
 // IN THE SOFTWARE.
 //------------------------------------------------------------------------------
 #include <cmath>
-#include "column/isna.h"
 #include "documentation.h"
 #include "expr/funary/pyfn.h"
 #include "expr/funary/umaker.h"
@@ -124,51 +123,6 @@ umaker_ptr resolve_op_sign(SType stype) {
   }
 }
 
-
-
-
-//------------------------------------------------------------------------------
-// Op::ISNA
-//------------------------------------------------------------------------------
-
-py::PKArgs args_isna(1, 0, 0, false, false, {"x"}, "isna", dt::doc_math_isna);
-
-
-template <typename T>
-class isna_umaker : public umaker {
-  public:
-    Column compute(Column&& col) const override {
-      return Column(new Isna_ColumnImpl<T>(std::move(col)));
-    }
-};
-
-
-umaker_ptr resolve_op_isna(SType stype) {
-  switch (stype) {
-    case SType::VOID: {
-      return umaker_ptr(new umaker_const(
-                            Const_ColumnImpl::make_bool_column(1, true)));
-    }
-    case SType::BOOL:
-    case SType::INT8:    return umaker_ptr(new isna_umaker<int8_t>());
-    case SType::INT16:   return umaker_ptr(new isna_umaker<int16_t>());
-    case SType::DATE32:
-    case SType::INT32:   return umaker_ptr(new isna_umaker<int32_t>());
-    case SType::TIME64:
-    case SType::INT64:   return umaker_ptr(new isna_umaker<int64_t>());
-    case SType::FLOAT32: return umaker_ptr(new isna_umaker<float>());
-    case SType::FLOAT64: return umaker_ptr(new isna_umaker<double>());
-    case SType::STR32:
-    case SType::STR64:   return umaker_ptr(new isna_umaker<CString>());
-    default:
-      throw TypeError() << "Function `isna` cannot be applied to a "
-                           "column of type `" << stype << "`";
-  }
-}
-
-
-
-
 //------------------------------------------------------------------------------
 // Op::ISINF
 //------------------------------------------------------------------------------