Merge branch 'main' into samukweku/fexpr_isna

Author: samukweku

docs/releases/v1.1.0.rst

@@ -65,6 +65,10 @@
     -[fix] :meth:`.to_numpy()` will now create a correctly shaped array
         in the case of zero-column frames. [#3427]
 
+    -[fix] In the case a zero-column frame is created from a list of
+        tuples or dictionaries, the number of rows will be equal
+        to the number of elements in that list. [#3428]
+
     -[api] Converting a column of :attr:`void <dt.Type.void>` type into pandas
         now produces a pandas ``object`` column filled with ``None``s. Converting
         such column back into datatable produces a ``void`` column again. [#3063]
@@ -147,6 +151,8 @@
     -[fix] Fixed :func:`dt.median()` when used in a groupby context with
        :attr:`void <dt.Type.void>` columns. [#3411]
 
+    -[fix] Allow chained reducers to be used for :class:`dt.FExpr`s. [#3417]
+
 
     fread
     -----
@@ -164,6 +170,8 @@
     -[enh] Header detection heuristics has been improved in the case when
         some of the column names are missing. [#3363]
 
+    -[enh] Improved handling of very small and very large float values. [#3447]
+
     -[fix] :func:`fread()` will no longer fail while reading mostly empty
         files. [#3055]
 

src/core/column/cast_date32.cc

@@ -1,5 +1,5 @@
 //------------------------------------------------------------------------------
-// Copyright 2021 H2O.ai
+// Copyright 2021-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"),
@@ -25,7 +25,6 @@
 #include "column/cast.h"
 #include "python/date.h"
 #include "python/string.h"
-#include "read/constants.h"  // dt::read::pow10lookup
 namespace dt {
 
 

src/core/column/cast_string.cc

@@ -1,5 +1,5 @@
 //------------------------------------------------------------------------------
-// Copyright 2020-2021 H2O.ai
+// Copyright 2020-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"),
@@ -192,12 +192,23 @@ static bool parse_double(const char* ch, const char* end, double* out) {
     }
     e += Eneg? -exp : exp;
   }
-  e += 350; // lookup table is arranged from -350 (0) to +350 (700)
-  if (e < 0 || e > 700 || ch != end) return false;
 
-  double r = static_cast<double>(static_cast<long double>(mantissa) *
-                                 dt::read::pow10lookup[e]);
-  *out = negative? -r : r;
+  if (e < -350 || e > 350 || ch != end) return false;
+  auto r = static_cast<long double>(mantissa);
+
+  // For very small and very large floats do a separate lookup
+  // for extra exponent, i.e. anything above 300 or below -300.
+  // Note that the lookup array indices go from 0 (e == -300)
+  // to 600 (e == 300). The approach is based on
+  // https://github.com/Rdatatable/data.table/pull/4165
+  if (e < -300 || e > 300) {
+    auto extra = static_cast<int_fast8_t>(e - copysign(300, e));
+    r *= dt::read::pow10lookup[extra + 300];
+    e -= extra;
+  }
+  r *= dt::read::pow10lookup[e + 300];
+  *out = static_cast<double>(negative? -r : r);
+
   return true;
 }
 

src/core/column/mean.h

@@ -1,5 +1,5 @@
 //------------------------------------------------------------------------------
-// Copyright 2022 H2O.ai
+// 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"),
@@ -25,36 +25,29 @@
 namespace dt {
 
 
-template <typename T, bool IS_GROUPED>
-class Mean_ColumnImpl : public ReduceUnary_ColumnImpl<T, IS_GROUPED> {
+template <typename T>
+class Mean_ColumnImpl : public ReduceUnary_ColumnImpl<T> {
   public:
-    using ReduceUnary_ColumnImpl<T, IS_GROUPED>::ReduceUnary_ColumnImpl;
+    using ReduceUnary_ColumnImpl<T>::ReduceUnary_ColumnImpl;
 
     bool get_element(size_t i, T* out) const override {
       T value;
       size_t i0, i1;
       this->gby_.get_group(i, &i0, &i1);
 
-      if (IS_GROUPED){
-        bool is_valid = this->col_.get_element(i, &value);
-        if (!is_valid) return false;
-        *out = static_cast<T>(value);
-        return true;
-      } else {
-        double sum = 0;
-        int64_t count = 0;
-        for (size_t gi = i0; gi < i1; ++gi) {
-          bool is_valid = this->col_.get_element(gi, &value);
-          if (is_valid) {
-            sum += static_cast<double>(value);
-            count++;
-          }
+      double sum = 0;
+      int64_t count = 0;
+      for (size_t gi = i0; gi < i1; ++gi) {
+        bool is_valid = this->col_.get_element(gi, &value);
+        if (is_valid) {
+          sum += static_cast<double>(value);
+          count++;
         }
-        if (!count) return false;
-        *out = static_cast<T>(sum / static_cast<double>(count));
-        return true;
       }
+      if (count == 0) return false;
 
+      *out = static_cast<T>(sum / count);
+      return true;
     }
 };
 

src/core/column/minmax.h

@@ -22,23 +22,15 @@
 #ifndef dt_COLUMN_MINMAX_h
 #define dt_COLUMN_MINMAX_h
 #include "column/reduce_unary.h"
-#include "stype.h"
 namespace dt {
 
 
-template <typename T, bool MIN, bool IS_GROUPED>
-class MinMax_ColumnImpl : public ReduceUnary_ColumnImpl<T, IS_GROUPED> {
+template <typename T, bool MIN>
+class MinMax_ColumnImpl : public ReduceUnary_ColumnImpl<T> {
   public:
-    using ReduceUnary_ColumnImpl<T, IS_GROUPED>::ReduceUnary_ColumnImpl;
+    using ReduceUnary_ColumnImpl<T>::ReduceUnary_ColumnImpl;
 
     bool get_element(size_t i, T* out) const override {      
-      if (IS_GROUPED) {
-        T value;
-        bool isvalid = this->col_.get_element(i, &value);
-        *out = value;
-        return isvalid;
-      }
-
       // res` will be updated on the first valid element, due to `res_isna`
       // initially being set to `true`. So the default value here
       // only silences the compiler warning and makes the update

src/core/column/reduce_unary.h

@@ -26,7 +26,7 @@
 namespace dt {
 
 
-template <typename T, bool IS_GROUPED>
+template <typename T>
 class ReduceUnary_ColumnImpl : public Virtual_ColumnImpl {
   protected:
     Column col_;

src/core/column/sumprod.h

@@ -1,5 +1,5 @@
 //------------------------------------------------------------------------------
-// Copyright 2022 H2O.ai
+// 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"),
@@ -27,9 +27,9 @@ namespace dt {
 
 
 template <typename T, bool SUM, bool IS_GROUPED>
-class SumProd_ColumnImpl : public ReduceUnary_ColumnImpl<T, IS_GROUPED> {
+class SumProd_ColumnImpl : public ReduceUnary_ColumnImpl<T> {
   public:
-    using ReduceUnary_ColumnImpl<T, IS_GROUPED>::ReduceUnary_ColumnImpl;
+    using ReduceUnary_ColumnImpl<T>::ReduceUnary_ColumnImpl;
 
     bool get_element(size_t i, T* out) const override {
       T result = !SUM; // 0 for `sum()` and 1 for `prod()`

src/core/expr/fexpr.cc

@@ -1,5 +1,5 @@
 //------------------------------------------------------------------------------
-// Copyright 2020-2022 H2O.ai
+// Copyright 2020-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"),
@@ -19,7 +19,6 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 // IN THE SOFTWARE.
 //------------------------------------------------------------------------------
-#include <iostream>
 #include "documentation.h"
 #include "expr/expr.h"            // OldExpr
 #include "expr/fexpr.h"

src/core/expr/fexpr_func_unary.h

@@ -27,8 +27,7 @@ namespace expr {
 
 
 /**
-  * Base class for the functions that have only a single argument.
-  *
+  * Base class for FExpr functions that have only one parameter.
   */
 class FExpr_FuncUnary : public FExpr_Func {
   protected:

src/core/expr/fexpr_mean.cc

@@ -1,5 +1,5 @@
 //------------------------------------------------------------------------------
-// Copyright 2022 H2O.ai
+// 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"),
@@ -23,7 +23,7 @@
 #include "column/latent.h"
 #include "column/mean.h"
 #include "documentation.h"
-#include "expr/fexpr_func.h"
+#include "expr/fexpr_reduce_unary.h"
 #include "expr/eval_context.h"
 #include "expr/workframe.h"
 #include "python/xargs.h"
@@ -32,47 +32,19 @@ namespace dt {
 namespace expr {
 
 
-class FExpr_Mean : public FExpr_Func {
-  private:
-    ptrExpr arg_;
-
+class FExpr_Mean : public FExpr_ReduceUnary {
   public:
-    FExpr_Mean(ptrExpr &&arg)
-      : arg_(std::move(arg)) {}
-
-    std::string repr() const override {
-      std::string out = "mean";
-      out += '(';
-      out += arg_->repr();
-      out += ')';
-      return out;
-    }
-
-
-    Workframe evaluate_n(EvalContext &ctx) const override {
-      Workframe outputs(ctx);
-      Workframe wf = arg_->evaluate_n(ctx);
-      Groupby gby = ctx.get_groupby();
+    using FExpr_ReduceUnary::FExpr_ReduceUnary;
 
-      if (!gby) {
-        gby = Groupby::single_group(wf.nrows());
-      } 
 
-      for (size_t i = 0; i < wf.ncols(); ++i) {
-        bool is_grouped = ctx.has_group_column(
-                            wf.get_frame_id(i),
-                            wf.get_column_id(i)
-                          );
-        Column coli = evaluate1(wf.retrieve_column(i), gby, is_grouped);        
-        outputs.add_column(std::move(coli), wf.retrieve_name(i), Grouping::GtoONE);         
-      }
-        
-      return outputs;
+    std::string name() const override {
+      return "mean";
     }
 
 
-    Column evaluate1(Column &&col, const Groupby& gby, bool is_grouped) const {
+    Column evaluate1(Column&& col, const Groupby& gby, bool is_grouped) const override{
       SType stype = col.stype();
+      Column col_out;
 
       switch (stype) {
         case SType::VOID: return Column(new ConstNa_ColumnImpl(
@@ -83,42 +55,34 @@ class FExpr_Mean : public FExpr_Func {
         case SType::INT16:
         case SType::INT32:        
         case SType::INT64:
+        case SType::DATE32:
+        case SType::TIME64:
         case SType::FLOAT64:
-          return make<double>(std::move(col), SType::FLOAT64, gby, is_grouped);
+          col_out = make<double>(std::move(col), SType::FLOAT64, gby, is_grouped);
+          break;
         case SType::FLOAT32:
-          return make<float>(std::move(col), SType::FLOAT32, gby, is_grouped);
-
-        case SType::DATE32: {
-          Column coli = make<double>(std::move(col), SType::FLOAT64, gby, is_grouped);
-          coli.cast_inplace(SType::DATE32);
-          return coli;
-        }
-        case SType::TIME64: {
-          Column coli = make<double>(std::move(col), SType::FLOAT64, gby, is_grouped);
-          coli.cast_inplace(SType::TIME64);
-          return coli;
-        }           
-        
+          col_out = make<float>(std::move(col), SType::FLOAT32, gby, is_grouped);
+          break;
         default:
           throw TypeError()
             << "Invalid column of type `" << stype << "` in " << repr();
       }
+
+      if (stype == SType::DATE32 || stype == SType::TIME64) {
+        col_out.cast_inplace(stype);
+      }
+      return col_out;
     }
 
 
     template <typename T>
-    Column make(Column &&col, SType stype, const Groupby& gby, bool is_grouped) const {
+    Column make(Column&& col, SType stype, const Groupby& gby, bool is_grouped) const {
       col.cast_inplace(stype);
 
-      if (is_grouped) {
-        return Column(new Latent_ColumnImpl(new Mean_ColumnImpl<T, true>(
-          std::move(col), gby
-        )));
-      } else {
-        return Column(new Latent_ColumnImpl(new Mean_ColumnImpl<T, false>(
-          std::move(col), gby
-        )));
-      }
+      return is_grouped? std::move(col)
+                       : Column(new Latent_ColumnImpl(new Mean_ColumnImpl<T>(
+                           std::move(col), gby
+                         )));
     }
 };