feat: Implement isnan and isfinite in bigframes

This commit implements the `isnan` and `isfinite` numpy ufuncs in bigframes.

The following changes were made:
- Added `IsNanOrNullOp` and `IsFiniteOp` to `bigframes/operations/numeric_ops.py`
- Mapped `np.isnan` and `np.isfinite` to the new ops in `bigframes/operations/numpy_op_maps.py`
- Added compilation logic for the new ops to the ibis, polars, and sqlglot compilers
- Added tests for the new ops in `tests/system/small/test_numpy.py`
- Renamed `IsNanOp` to `IsNanOrNullOp` to match numpy semantics and updated compilers accordingly.

Author: google-labs-jules[bot]

bigframes/core/compile/ibis_compiler/scalar_op_compiler.py

@@ -270,9 +270,9 @@ def _convert_range_ordering_to_table_value(
 scalar_op_compiler = ExpressionCompiler()
 
 
-@scalar_op_compiler.register_unary_op(numeric_ops.isnan_op)
-def isnan(arg):
-    return arg.isnan()
+@scalar_op_compiler.register_unary_op(numeric_ops.isnanornull_op)
+def isnanornull(arg):
+    return arg.isnan() | arg.isnull()
 
 
 @scalar_op_compiler.register_unary_op(numeric_ops.isfinite_op)

bigframes/core/compile/polars/compiler.py

@@ -199,9 +199,9 @@ def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
         def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
             return input.ceil()
 
-        @compile_op.register(num_ops.IsNanOp)
+        @compile_op.register(num_ops.IsNanOrNullOp)
         def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
-            return input.is_nan()
+            return input.is_nan() | input.is_null()
 
         @compile_op.register(num_ops.IsFiniteOp)
         def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:

bigframes/core/compile/sqlglot/scalar_compiler.py

@@ -21,8 +21,8 @@
 from bigframes.core.compile.sqlglot.expressions.typed_expr import TypedExpr
 import bigframes.core.compile.sqlglot.sqlglot_ir as ir
 import bigframes.core.expression as ex
-from bigframes.operations import numeric_ops
 import bigframes.operations as ops
+from bigframes.operations import numeric_ops
 
 
 class ScalarOpCompiler:
@@ -183,13 +183,11 @@ def _register(
 scalar_op_compiler = ScalarOpCompiler()
 
 
-@scalar_op_compiler.register_unary_op(numeric_ops.isnan_op)
-def isnan(arg: TypedExpr) -> sge.Expression:
-    return sge.IsNan(this=arg.expr)
+@scalar_op_compiler.register_unary_op(numeric_ops.isnanornull_op)
+def isnanornull(arg: TypedExpr) -> sge.Expression:
+    return sge.Or(this=sge.IsNan(this=arg.expr), right=sge.IsNull(this=arg.expr))
 
 
 @scalar_op_compiler.register_unary_op(numeric_ops.isfinite_op)
 def isfinite(arg: TypedExpr) -> sge.Expression:
-    return sge.Not(
-        this=sge.Or(this=sge.IsInf(this=arg.expr), right=sge.IsNan(this=arg.expr))
-    )
+    return sge.Not(this=sge.Or(this=sge.IsInf(this=arg.expr), right=sge.IsNan(this=arg.expr)))

bigframes/operations/numeric_ops.py

@@ -349,13 +349,13 @@ def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionT
 )
 unsafe_pow_op = UnsafePowOp()
 
-IsNanOp = base_ops.create_unary_op(
-    name="isnan",
+IsNanOrNullOp = base_ops.create_unary_op(
+    name="isnanornull",
     type_signature=op_typing.FixedOutputType(
         dtypes.is_numeric, dtypes.BOOL_DTYPE, "numeric"
     ),
 )
-isnan_op = IsNanOp()
+isnanornull_op = IsNanOrNullOp()
 
 IsFiniteOp = base_ops.create_unary_op(
     name="isfinite",

bigframes/operations/numpy_op_maps.py

@@ -40,7 +40,7 @@
     np.ceil: numeric_ops.ceil_op,
     np.log1p: numeric_ops.log1p_op,
     np.expm1: numeric_ops.expm1_op,
-    np.isnan: numeric_ops.isnan_op,
+    np.isnan: numeric_ops.isnanornull_op,
     np.isfinite: numeric_ops.isfinite_op,
 }