cast inplace for mean

Author: samukweku

src/core/column/mean.h

@@ -25,20 +25,20 @@
 namespace dt {
 
 
-template <typename T_IN, typename T_OUT, bool IS_GROUPED>
-class Mean_ColumnImpl : public ReduceUnary_ColumnImpl<T_IN, T_OUT, IS_GROUPED> {
+template <typename T_IN, bool IS_GROUPED>
+class Mean_ColumnImpl : public ReduceUnary_ColumnImpl<T_IN, T_IN, IS_GROUPED> {
   public:
-    using ReduceUnary_ColumnImpl<T_IN, T_OUT, IS_GROUPED>::ReduceUnary_ColumnImpl;
+    using ReduceUnary_ColumnImpl<T_IN, T_IN, IS_GROUPED>::ReduceUnary_ColumnImpl;
 
-    bool get_element(size_t i, T_OUT* out) const override {
+    bool get_element(size_t i, T_IN* out) const override {
       T_IN 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_OUT>(value);
+        *out = value;
         return true;
       } else {
         double sum = 0;
@@ -51,7 +51,7 @@ class Mean_ColumnImpl : public ReduceUnary_ColumnImpl<T_IN, T_OUT, IS_GROUPED> {
           }
         }
         if (!count) return false;
-        *out = static_cast<T_OUT>(sum / static_cast<double>(count));
+        *out = static_cast<T_IN>(sum / static_cast<double>(count));
         return true;
       }
 

src/core/expr/fexpr_mean.cc

@@ -80,42 +80,41 @@ class FExpr_Mean : public FExpr_Func {
                           ));
         case SType::BOOL:
         case SType::INT8:
-          return make<int8_t, double>(std::move(col), gby, is_grouped);
         case SType::INT16:
-          return make<int16_t, double>(std::move(col), gby, is_grouped);
-        case SType::INT32:   
-          return make<int32_t, double>(std::move(col), gby, is_grouped);     
+        case SType::INT32:        
         case SType::INT64:
-          return make<int64_t, double>(std::move(col), gby, is_grouped);
         case SType::FLOAT64:
-          return make<double, double>(std::move(col), gby, is_grouped);
+          return make<double>(std::move(col), SType::FLOAT64, gby, is_grouped);
         case SType::FLOAT32:
-          return make<float, float>(std::move(col), gby, is_grouped);
+          return make<float>(std::move(col), SType::FLOAT32, gby, is_grouped);
+
         case SType::DATE32: {
-          Column coli = make<double, double>(std::move(col), gby, is_grouped);
+          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, double>(std::move(col), gby, is_grouped);
+          Column coli = make<double>(std::move(col), SType::FLOAT64, gby, is_grouped);
           coli.cast_inplace(SType::TIME64);
           return coli;
-        }             
+        }           
+        
         default:
           throw TypeError()
             << "Invalid column of type `" << stype << "` in " << repr();
       }
     }
 
 
-    template <typename T_IN, typename T_OUT>
-    Column make(Column &&col, const Groupby& gby, bool is_grouped) const {
+    template <typename T_IN>
+    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_IN, T_OUT, true>(
+        return Column(new Latent_ColumnImpl(new Mean_ColumnImpl<T_IN, true>(
           std::move(col), gby
         )));
       } else {
-        return Column(new Latent_ColumnImpl(new Mean_ColumnImpl<T_IN, T_OUT, false>(
+        return Column(new Latent_ColumnImpl(new Mean_ColumnImpl<T_IN, false>(
           std::move(col), gby
         )));
       }