Merge pull request #154 from opensource9ja/browser-groupby

Groupby  update

Author: steveoni

danfojs-browser/lib/bundle.js

@@ -146,23 +146,6 @@
  * =============================================================================
  */
 
-/**
- * @license
- * Copyright 2021 Google LLC. All Rights Reserved.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * =============================================================================
- */
-
 /**
  * @license Complex.js v2.0.11 11/02/2016
  *

danfojs-browser/lib/bundle.js.LICENSE.txt

@@ -15,6 +15,7 @@ export class Concat {
 
     let df_list = null; //set the df_list to null
     let axis = null; // set axis to null
+    let indexes = null;
 
     //check if df_list is an array
     if (Array.isArray(kwargs["df_list"])) {
@@ -41,13 +42,14 @@ export class Concat {
 
 
     let df_object = Object.assign({}, df_list); // convert the array to object
-
+    
     if (axis == 1) {
 
       let columns = [];
       let duplicate_col_count = {};
       let max_length = 0;
-
+      let a_key = Object.keys(df_object)[0];
+      indexes = df_object[a_key].index;
       for (let key in df_object) {
 
         let column = df_object[key].columns;
@@ -121,15 +123,22 @@ export class Concat {
         }
       }
 
-      let df = new DataFrame(data, { columns: columns }); //convert to dataframe
+      let df = new DataFrame(data, { columns: columns, index: indexes }); //convert to dataframe
       return df;
     } else {
       //concatenate base on axis 0
       let columns = [];
-
+      let row_indexes = [];
+      let col_i = 0;
       for (let key in df_list) {
         let column = df_list[key].columns;
         columns.push(...column);
+        indexes = df_list[key].index;
+        let r_index = indexes.map((val) => {
+          return `${val}_row${col_i}`;
+        });
+        row_indexes.push(...r_index);
+        col_i += 1;
       }
 
       let column_set = new Set(columns);
@@ -187,10 +196,10 @@ export class Concat {
       }
 
       if (Array.isArray(data[0])){
-        let df = new DataFrame(data, { columns: columns });
+        let df = new DataFrame(data, { columns: columns, index: row_indexes });
         return df;
       } else {
-        let sf = new Series(data);
+        let sf = new Series(data, { index: row_indexes });
         return sf;
       }
 

danfojs-browser/lib/bundle.js.map

@@ -1,5 +1,6 @@
 import { DataFrame } from "./frame";
 import { Utils } from "./utils";
+import { Series } from "./series";
 const utils = new Utils;
 
 /**
@@ -101,7 +102,7 @@ export class GroupBy {
      * @return Groupby data structure
      */
   col(col_names){
-
+    this.selected_column = col_names; // store col_names for use later in .apply
     if (Array.isArray(col_names)){
 
       for (let i = 0; i < col_names.length; i++){
@@ -115,44 +116,50 @@ export class GroupBy {
       throw new Error(`Col_name must be an array of column`);
     }
 
-    this.group_col_name = col_names; // store the column name
+    // let group_col_name = col_names; // store the column name
+    let group_col = {};
     if (this.key_col.length == 2){
 
-      this.group_col = {};
-
       for (var key1 in this.data_tensors){
 
-        this.group_col[key1] = {};
+        group_col[key1] = {};
         for (var key2 in this.data_tensors[key1]){
 
-          this.group_col[key1][key2] = [];
+          group_col[key1][key2] = [];
           for (let i = 0; i < col_names.length; i++){
             let col_name = col_names[i];
             let data = this.data_tensors[key1][key2].column(col_name);
-            this.group_col[key1][key2].push(data);
+            group_col[key1][key2].push(data);
           }
 
         }
       }
     } else {
-
-      this.group_col = {};
-
       for (let key1 in this.data_tensors){
 
-        this.group_col[key1] = [];
+        group_col[key1] = [];
         for (let i = 0; i < col_names.length; i++){
           let col_name = col_names[i];
           let data = this.data_tensors[key1].column(col_name);
-          this.group_col[key1].push(data);
+          group_col[key1].push(data);
         }
 
       }
     }
-
-    return this;
+    const gp = new GroupBy(
+      null,
+      this.key_col,
+      null,
+      col_names
+    );
+
+    gp.group_col = group_col;
+    gp.group_col_name = col_names;
+    // return gp;
+    return gp;
   }
 
+
   /**
      * Basic root of all column arithemetic in groups
      * @param {operation} operatioin String
@@ -178,8 +185,8 @@ export class GroupBy {
     //the local variable to store variables to be used in eval
     // this seems not to be needed in Node version, since local
     //variable are easily accessed in the eval function
-    let local = null; 
-    
+    let local = null;
+
     if (Array.isArray(operation)){
       is_array = true;
     }
@@ -248,70 +255,60 @@ export class GroupBy {
 
   }
 
+  operations(ops, name) {
+    if (!this.group_col) {
+      let column = this.column_name.filter((val) => !this.key_col.includes(val));
+      let col_gp = this.col(column);
+      let value = col_gp.arithemetic(ops);
+      let df = col_gp.to_DataFrame(col_gp.key_col, col_gp.group_col_name, value, name);
+      return df;
+    } else {
+      let value = this.arithemetic(ops);
+      let df = this.to_DataFrame(this.key_col, this.group_col_name, value, name);
+      return df;
+    }
+  }
   count(){
-
-    let value = this.arithemetic("count()");
-    let df = this.to_DataFrame(this.key_col, this.group_col_name, value, "count");
-    return df;
+    return this.operations("count()", "count");
   }
 
   sum(){
-    let value = this.arithemetic("sum()");
-    let df = this.to_DataFrame(this.key_col, this.group_col_name, value, "sum");
-    return df;
+    return this.operations("sum()", "sum");
   }
 
   std(){
-    let value = this.arithemetic("std()");
-    let df = this.to_DataFrame(this.key_col, this.group_col_name, value, "std");
-    return df;
+    return this.operations("std()", "std");
   }
 
   var(){
-    let value = this.arithemetic("var()");
-    let df = this.to_DataFrame(this.key_col, this.group_col_name, value, "var");
-    return df;
+    return this.operations("var()", "var");
   }
 
   mean(){
-    let value = this.arithemetic("mean()");
-    let df = this.to_DataFrame(this.key_col, this.group_col_name, value, "mean");
-    return df;
+    return this.operations("mean()", "mean");
   }
 
   cumsum(){
-    let value = this.arithemetic("cumsum().values");
-    let df = this.to_DataFrame(this.key_col, this.group_col_name, value, "cumsum");
-    return df;
+    return this.operations("cumsum().values", "cumsum");
   }
   cummax(){
-    let value = this.arithemetic("cummax().values");
-    let df = this.to_DataFrame(this.key_col, this.group_col_name, value, "cummax");
-    return df;
+    return this.operations("cummax().values", "cummax");
   }
 
   cumprod(){
-    let value = this.arithemetic("cumprod().values");
-    let df = this.to_DataFrame(this.key_col, this.group_col_name, value, "cumprod");
-    return df;
+    return this.operations("cumprod().values", "cumprod");
   }
 
   cummin(){
-    let value = this.arithemetic("cummin().values");
-    let df = this.to_DataFrame(this.key_col, this.group_col_name, value, "cummin");
-    return df;
+    return this.operations("cummin().values", "cummin");
   }
 
   max(){
-    let value = this.arithemetic("max()");
-    let df = this.to_DataFrame(this.key_col, this.group_col_name, value, "max");
-    return df;
+    return this.operations("max()", "max");
   }
 
   min(){
-    let value = this.arithemetic("min()");
-    let df = this.to_DataFrame(this.key_col, this.group_col_name, value, "min");
-    return df;
+    return this.operations("min()", "min");
   }
 
   /**
@@ -350,17 +347,16 @@ export class GroupBy {
     let columns = Object.keys(kwargs);
     let operations = columns.map((x) => { return kwargs[x].toLocaleLowerCase(); });
 
-    this.col(columns);
+    let col_gp = this.col(columns);
 
-    let data = this.arithemetic(operations);
-    let df = this.to_DataFrame(this.key_col, this.group_col_name, data, operations);
+    let data = col_gp.arithemetic(operations);
+    let df = this.to_DataFrame(col_gp.key_col, col_gp.group_col_name, data, operations);
 
     return df;
   }
 
   to_DataFrame(key_col, col, data, ops){
 
-    // console.log(data);
     if (key_col.length == 2){
       let df_data = [];
       for (let key_1 in data){
@@ -455,4 +451,61 @@ export class GroupBy {
     }
   }
 
+  apply(callable){
+    let df_data;
+    let column;
+    if (!this.group_col) {
+      column = this.column_name.filter((val) => !this.key_col.includes(val));
+      let col_gp = this.col(column);
+      df_data = col_gp.group_col;
+    } else {
+      column = this.group_col_name;
+      df_data = this.group_col;
+    }
+    let data = [];
+    let count_group = {};
+    if (this.key_col.length == 2) {
+
+      for (let key in this.data_tensors) {
+        count_group[key] = {};
+        for (let key2 in this.data_tensors[key]) {
+          count_group[key][key2] = [];
+          for (let i = 0; i < df_data[key][key2].length; i++ ) {
+            let callable_rslt = callable(df_data[key][key2][i]);
+            if (callable_rslt instanceof DataFrame) {
+              count_group[key][key2].push(callable_rslt.values);
+            } else {
+              if (callable_rslt instanceof Series) {
+                count_group[key][key2].push(callable_rslt.values);
+              } else {
+                count_group[key][key2].push(callable_rslt);
+              }
+            }
+          }
+
+
+        }
+      }
+    } else {
+      for (let key in df_data) {
+        count_group[key] = [];
+        for (let i = 0; i < df_data[key].length; i++ ){
+          let callable_rslt = callable(df_data[key][i]);
+          if (callable_rslt instanceof DataFrame) {
+            count_group[key].push(callable_rslt.values);
+          } else {
+            if (callable_rslt instanceof Series) {
+              count_group[key].push(callable_rslt.values);
+            } else {
+              count_group[key].push(callable_rslt);
+            }
+
+          }
+        }
+
+      }
+    }
+    return this.to_DataFrame(this.key_col, column, count_group, "apply");
+  }
+
 }

danfojs-browser/src/core/concat.js

@@ -1,4 +1,3 @@
-
 describe("Concatenate", function () {
 
   it("Check the axis 0 concatenation", function () {
@@ -44,7 +43,7 @@ describe("Concatenate", function () {
     assert.deepEqual(new_df.values, data_values);
   });
 
-  it("concatenate dfd.dataframe and series along 0 axis", function(){
+  it("concatenate dataframe and series along 0 axis", function(){
 
     let data1 = [ 1, 2, 3, 4 ];
     let data2 = [ 3, 4, 5, 6 ];
@@ -73,7 +72,7 @@ describe("Concatenate", function () {
 
   });
 
-  it("concatenate dfd.dataframe and series along axis 1", function(){
+  it("concatenate dataframe and series along axis 1", function(){
 
     let data = [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 20, 30, 40 ], [ 39, 89, 78 ] ];
     let cols = [ "A", "B", "C" ];

danfojs-browser/src/core/groupby.js

@@ -2276,7 +2276,7 @@ describe("DataFrame", function () {
       let df2 = new dfd.DataFrame([ [ 20, 40, 60, "d" ] ], { "columns": [ "col1", "col2", "col3", "col4" ] });
 
       let rslt_df = df.append(df2);
-      assert.deepEqual(rslt_df.index, [ 0, 1, 2, 3 ]);
+      assert.deepEqual(rslt_df.index, [ "0_row0", "1_row0", "2_row0", "0_row1" ]);
 
     });
   });