Merge branch 'master' of https://github.com/opensource9ja/danfojs

Author: risenW

README.md

@@ -7,6 +7,8 @@
 
 ## danfojs: powerful javascript data analysis toolkit 
 ![Node.js CI](https://github.com/opensource9ja/danfojs/workflows/Node.js%20CI/badge.svg?branch=master)
+[![](https://data.jsdelivr.com/v1/package/npm/danfojs/badge?style=rounded)](https://www.jsdelivr.com/package/npm/danfojs)
+
 
 
 ## What is it?
@@ -179,9 +181,6 @@ To use danfo.js via script tags, copy and paste the CDN below to your HTML file
 </html>
 ```
 
-### To install Node.js version, go [here](https://www.npmjs.com/package/danfojs-node)
-
-
 ## Installation from sources
 To install danfo in [development mode], clone the repo:
 

danfojs/src/core/frame.js

@@ -4,7 +4,7 @@ import { Series } from "./series"
 import * as tf from '@tensorflow/tfjs'
 import { Utils } from "./utils"
 import { GroupBy } from "./groupby"
-import { Plot } from '../plotting/plot'
+// import { Plot } from '../plotting/plot'
 import { indexLoc } from '../core/indexing'
 
 const utils = new Utils
@@ -1895,10 +1895,10 @@ export class DataFrame extends Ndframe {
      * @param {string} div Name of the div to show the plot
      * @param {Object} config configuration options for making Plots, supports Plotly parameters
      */
-    plot(div, config = {}) {
-        const plt = new Plot()
-        plt.plot(this, div, config)
-    }
+    // plot(div, config = {}) {
+    //     const plt = new Plot()
+    //     plt.plot(this, div, config)
+    // }
 
 
     /**

danfojs/src/core/groupby.js

@@ -120,7 +120,7 @@ export class GroupBy {
             throw new Error(`Col_name must be an array of column`)
         }
 
-
+        this.group_col_name = col_names // store the column name
         if(this.key_col.length ==2){
 
             this.group_col = {}
@@ -165,13 +165,20 @@ export class GroupBy {
      */
     arithemetic(operation){
 
-        let ops_name = ["mean","sum","count","mode"]
+        let ops_name = ["mean","sum","count","mode","std","var","cumsum","cumprod",
+                        "cummax","cummin"]
 
         let ops_map = {
             "mean": "mean()",
             "sum": "sum()",
             "mode": "mode()",
-            "count": "count()"
+            "count": "count()",
+            "std" : "std()",
+            "var" : "var()",
+            "cumsum" : "cumsum().values",
+            "cumprod": "cumprod().values",
+            "cummax" : "cummax().values",
+            "cummin" : "cummin().values"
         }
         let is_array = false;
 
@@ -201,8 +208,11 @@ export class GroupBy {
                         }else{
                             data = eval(`this.group_col[key1][key2][i].${operation}`)
                         }
-                        
-                        count_group[key1][key2].push(data)
+                        if(Array.isArray(data)){
+                            count_group[key1][key2].push(...data)
+                        }else{
+                            count_group[key1][key2].push(data)
+                        }
                     }
 
                 }
@@ -227,8 +237,12 @@ 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)
                 }
             }
 
@@ -241,15 +255,56 @@ export class GroupBy {
     count(){
 
         let value = this.arithemetic("count()");
-        return value;
+        let df = this.to_DataFrame(this.key_col, this.group_col_name,value,"count")
+        return df
     }
 
     sum(){
         let value = this.arithemetic("sum()")
-        return value
+        let df = this.to_DataFrame(this.key_col, this.group_col_name,value,"sum")
+        return df
+    }
+
+    std(){
+        let value = this.arithemetic("std()")
+        let df = this.to_DataFrame(this.key_col, this.group_col_name,value,"std")
+        return df
+    }
+
+    var(){
+        let value = this.arithemetic("var()")
+        let df = this.to_DataFrame(this.key_col, this.group_col_name,value,"var")
+        return df
     }
 
+    mean(){
+        let value = this.arithemetic("mean()")
+        let df = this.to_DataFrame(this.key_col, this.group_col_name,value,"mean")
+        return df
+    }
 
+    cumsum(){
+        let value = this.arithemetic("cumsum().values")
+        let df = this.to_DataFrame(this.key_col, this.group_col_name,value,"cumsum")
+        return df
+    }
+    cummax(){
+        let value = this.arithemetic("cummax().values")
+        let df = this.to_DataFrame(this.key_col, this.group_col_name,value,"cummax")
+        return df
+    }
+
+    cumprod(){
+        let value = this.arithemetic("cumprod().values")
+        let df = this.to_DataFrame(this.key_col, this.group_col_name,value,"cumprod")
+        return df
+    }
+
+    cummin(){
+        let value = this.arithemetic("cummin().values")
+        let df = this.to_DataFrame(this.key_col, this.group_col_name,value,"cummin")
+        return df
+    }
 
     /**
      * returns dataframe of a group
@@ -293,8 +348,63 @@ export class GroupBy {
         this.col(columns)
 
         let data = this.arithemetic(operations)
+        let df = this.to_DataFrame(this.key_col,this.group_col_name,data,operations)
+
+        return df;
+    }
 
-        return data;
+    to_DataFrame(key_col,col,data,ops){
+
+        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_1 : parseInt(key_2)
+                    kk.push(...k_data)
+                    df_data.push(kk)
+
+                }
+                
+            }
+            let column = [...key_col]
+
+            let group_col = col.slice().map((x,i)=>{
+                if(Array.isArray(ops)){
+                    return `${x}_${ops[i]}`
+                }
+                return `${x}_${ops}`
+            });
+            column.push(...group_col);
+            return new DataFrame(df_data,{columns: column})
+        }else{
+            let df_data = []
+            for(let key_1 in data){
+
+                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)
+            }
+            let column = [...key_col]
+            let group_col = col.slice().map((x,i)=>{
+                if(ops.length >1){
+                    return `${x}_${ops[i]}`
+                }
+                return `${x}_${ops}`
+            });
+            column.push(...group_col);
+
+            return new DataFrame(df_data,{columns: column})
+        }
     }
 
 }

danfojs/src/core/series.js

@@ -106,9 +106,11 @@ export class Series extends NDframe {
             let new_values = []
             let new_idx = []
 
-            let counts = [...Array(idx.length).keys()]   //set index
+            // let counts = [...Array(idx.length).keys()]   //set index
             //get random sampled numbers
-            let rand_nums = utils.__randgen(num, 0, counts.length)
+            // let index_arr = utils.__range(0,counts.length)
+            let rand_nums = utils.__shuffle(num,idx)
+            // console.log(rand_nums)
             rand_nums.map(i => {
                 new_values.push(values[i])
                 new_idx.push(idx[i])

danfojs/src/core/utils.js

@@ -637,6 +637,26 @@ export class Utils {
         }
         return zero_data
     }
+
+    __shuffle(num,array) {
+        //https://stackoverflow.com/questions/18806210/generating-non-repeating-random-numbers-in-js/18806417
+        var i = array.length,
+            j = 0,
+            temp;
+    
+        while (i--) {
+    
+            j = Math.floor(Math.random() * (i+1));
+    
+            // swap randomly chosen element with current element
+            temp = array[i];
+            array[i] = array[j];
+            array[j] = temp;
+    
+        }
+    
+        return array.slice(0,num);
+    }
 }