reformat the multindex dataframe fro groupby

Author: steveoni

danfojs/src/core/groupby.js

@@ -208,11 +208,8 @@ export class GroupBy {
                         }else{
                             data = eval(`this.group_col[key1][key2][i].${operation}`)
                         }
-                        if(Array.isArray(data)){
-                            count_group[key1][key2].push(...data)
-                        }else{
-                            count_group[key1][key2].push(data)
-                        }
+                        count_group[key1][key2].push(data)
+                    
                     }
 
                 }
@@ -237,11 +234,8 @@ export class GroupBy {
                     }else{
                         data = eval(`this.group_col[key1][i].${operation}`)
                     }
-                    if(Array.isArray(data)){
-                        count_group[key1].push(...data)
-                    }else{
-                        count_group[key1].push(data)
-                    }
+                    
+                    count_group[key1].push(data)
 
                 }
             }
@@ -367,20 +361,43 @@ export class GroupBy {
 
     to_DataFrame(key_col,col,data,ops){
 
+        // console.log(data);
         if(key_col.length ==2){
-
             let df_data = []
             for(let key_1 in data){
 
                 let key_val = data[key_1]
 
                 for(let key_2 in key_val){
                     let k_data = key_val[key_2]
-                    let kk = []
-                    kk[0] = isNaN(parseInt(key_1)) ? key_1 : parseInt(key_1)
-                    kk[1] = isNaN(parseInt(key_2)) ? key_2 : parseInt(key_2)
-                    kk.push(...k_data)
-                    df_data.push(kk)
+                    let key_data = []
+                    
+
+                    if(Array.isArray(k_data[0])){
+                        for(let i=0; i < k_data.length; i++){
+                            let col_data = k_data[i]
+    
+                            for (let j=0; j < col_data.length; j++ ){
+                                
+                                if(typeof key_data[j] === "undefined" ){
+                                    key_data[j] = []
+                                    key_data[j][0] = isNaN(parseInt(key_1)) ? key_1 : parseInt(key_1)
+                                    key_data[j][1] = isNaN(parseInt(key_2)) ? key_2 : parseInt(key_2)
+                                    key_data[j].push(col_data[j])
+                                }else{
+                                    key_data[j].push(col_data[j]);
+                                }
+                            }
+                        }
+                        df_data.push(...key_data)
+    
+                    }else{
+                        key_data[0] = isNaN(parseInt(key_1)) ? key_1 : parseInt(key_1)
+                        key_data[1] = isNaN(parseInt(key_2)) ? key_2 : parseInt(key_2)
+                        key_data.push(...k_data)
+                        df_data.push(key_data)
+                    }
+                    
 
                 }
 
@@ -402,9 +419,29 @@ export class GroupBy {
                 let key_val = data[key_1]
 
                 let key_data = []
-                key_data[0] = isNaN(parseInt(key_1)) ? key_1 : parseInt(key_1)
-                key_data.push(...key_val)
-                df_data.push(key_data)
+                if(Array.isArray(key_val[0])){
+                    for(let i=0; i < key_val.length; i++){
+                        let col_data = key_val[i]
+
+                        for (let j=0; j < col_data.length; j++ ){
+
+                            if(typeof key_data[j] === "undefined" ){
+                                key_data[j] = []
+                                key_data[j][0] = isNaN(parseInt(key_1)) ? key_1 : parseInt(key_1)
+                                key_data[j].push(col_data[j])
+                            }else{
+                                key_data[j].push(col_data[j]);
+                            }
+                        }
+                        df_data.push(...key_data)
+                    }
+
+                }else{
+                    key_data[0] = isNaN(parseInt(key_1)) ? key_1 : parseInt(key_1)
+                    key_data.push(...key_val)
+                    df_data.push(key_data)
+                }
+                
             }
             let column = [...key_col]
             let group_col = col.slice().map((x,i)=>{

danfojs/tests/core/groupby.js

@@ -181,4 +181,57 @@ describe("groupby", function () {
         assert.deepEqual(group_df.col(["B", "C"]).mean().values, new_data);
     });
 
+    it("printing multiindex table, example with cumsum operation for dataframe group by one column",function(){
+        let data =[{'A': ['foo', 'bar', 'foo', 'bar',
+                         'foo', 'bar', 'foo', 'foo']},
+            {'B': ['one', 'one', 'two', 'three',
+                    'two', 'two', 'one', 'three']},
+            {'C': [1,3,2,4,5,2,6,7]},
+            {'D': [3,2,4,1,5,6,7,8]}
+        ]
+
+            let df = new DataFrame(data)
+
+
+        let grp = df.groupby(["A"])
+        let rslt = [
+            [ 'foo', 1 ],
+            [ 'foo', 3 ],
+            [ 'foo', 8 ],
+            [ 'foo', 14 ],
+            [ 'foo', 21 ],
+            [ 'bar', 3 ],
+            [ 'bar', 7 ],
+            [ 'bar', 9 ]
+          ]
+        assert.deepEqual(grp.col(["C"]).cumsum().values, rslt);
+
+    })
+    it("printing multiindex table, example with cumsum operation for dataframe group by one column",function(){
+        let data =[{'A': ['foo', 'bar', 'foo', 'bar',
+                         'foo', 'bar', 'foo', 'foo']},
+            {'B': ['one', 'one', 'two', 'three',
+                    'two', 'two', 'one', 'three']},
+            {'C': [1,3,2,4,5,2,6,7]},
+            {'D': [3,2,4,1,5,6,7,8]}
+        ]
+
+            let df = new DataFrame(data)
+
+
+        let grp = df.groupby(["A","B"])
+        let rslt = [
+            [ 'foo', 'one', 1, 3 ],
+            [ 'foo', 'one', 7, 10 ],
+            [ 'foo', 'two', 2, 4 ],
+            [ 'foo', 'two', 7, 9 ],
+            [ 'foo', 'three', 7, 8 ],
+            [ 'bar', 'one', 3, 2 ],
+            [ 'bar', 'two', 2, 6 ],
+            [ 'bar', 'three', 4, 1 ]
+          ]
+        assert.deepEqual(grp.col(["C","D"]).cumsum().values,rslt)
+
+    })
+
 });