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

Author: steveoni

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/generic.js

@@ -32,9 +32,11 @@ export default class NDframe {
         } else {
             this.series = false
             if (utils.__is_object(data[0])) { //check the type of the first object in the data
-                this.__read_object(data)
+                this.__read_object(data, 1) //type 1 object are of JSON form [{a: 1, b: 2}, {a: 30, b: 20}]
             } else if (Array.isArray(data[0]) || utils.__is_number(data[0]) || utils.__is_string(data[0])) {
                 this.__read_array(data)
+            } else if (utils.__is_object(data)) {
+                this.__read_object(data, 2)  //type 2 object are of the form {a: [1,2,3,4], b: [30,20, 30, 20}]
             } else {
                 throw "File format not supported for now"
             }
@@ -92,19 +94,19 @@ export default class NDframe {
 
 
     //Reads a Javascript Object of arrays of data points
-    __read_object(data) {
-        let data_arr = []
-        //check format of objects
-        let _key = Object.keys(data[0])[0]  //get first column name in data
-        if (Array.isArray(data[0][_key])) {
-            // format of data is [{"a": [1,2,3,4]}, {"b": [2,4,5,7]}]
+    __read_object(data, type) {
+        if (type == 2) {
+            let data_arr = []
+
+            // format of data is {"a": [1,2,3,4], "b": [2,4,5,7]}
             let result = utils.__get_row_values(data)
             data_arr = result[0]
             this.kwargs['columns'] = result[1]
-            //call read array on result since it is an array of array format
             this.__read_array(data_arr)
         } else {
             //format of data is [{"a": 1, "b" : 2}, {"a": 2, "b" : 4}, {"a": 4, "b" : 5}]
+            let data_arr = []
+
             data.forEach((item) => {
                 data_arr.push(Object.values(item))
             });
@@ -355,7 +357,7 @@ export default class NDframe {
             return JSON.stringify(json_arr)
         }
     }
-    
+
 
     /**
     * Prints the data in a Series as a grid of row and columns

danfojs/src/core/utils.js

@@ -149,28 +149,22 @@ export class Utils {
     // let data = [{ alpha: ["A", "B", "C", "D"] }, { count: [1,2,3,4]}, {sum: [20.3, 30.456, 40.90, 90.1]}]
 
 
-    //transpose column array into row array
+    //retrieve row array from column object
     __get_row_values(data) {
-        let rows_len = Object.values(data[0])[0].length
-        let cols_len = data.length
+        let col_names = Object.keys(data)
+        let col_data = Object.values(data)
+        let rows_len = col_data[0].length
+        let cols_len = col_names.length
         var rows_arr = []
 
         for (var i = 0; i <= rows_len - 1; i++) {
             var temp_row = []
             for (let j = 0; j < cols_len; j++) {
-                let _arr = Object.values(data[j])[0]
+                let _arr = col_data[j]
                 temp_row.push(_arr[i])
             }
             rows_arr.push(temp_row)
         }
-        //get column names
-        let col_names = []
-        for (let i = 0; i < cols_len; i++) {
-            let _key = Object.keys(data[i])[0]
-            col_names.push(_key)
-
-        }
-
         return [rows_arr, col_names]
 
     }
@@ -638,24 +632,24 @@ export class Utils {
         return zero_data
     }
 
-    __shuffle(num,array) {
+    __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));
-    
+
+            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);
+
+        return array.slice(0, num);
     }
 }
 

danfojs/src/plotting/plot.js

@@ -1,80 +1,166 @@
-// //perform plotting
-// // import {newPlot} from 'plotly.js/dist/plotly'
-// import { Utils } from "../core/utils"
-// const utils = new Utils()
-
-
-
-// /**
-//  * Plotting methods and Functions performed on Series and DataFrames
-//  */
-// export class Plot {
-//     constructor() {}
-
-//     plot(ndframe, div, config) {
-//         let params = Object.keys(config)
-//         let this_config = {}
-
-//         if (!utils.__key_in_object(config, "layout")){
-//             this_config['layout'] = {}
-//         }
-
-//         params.forEach(param => {
-//             this_config[param] = config[param]
-//         })
-
-//         if (ndframe.series) {
-//             let x = ndframe.values
-//             let trace = {
-//                 x: x,
-//                 type: this_config["kind"],
-//                 mode: this_config["mode"]
-//             }
-//             newPlot(div, [trace], this_config['layout']);
-
-//         } else {
-//             //DataFrame
-//             if (utils.__key_in_object(this_config, 'x') && utils.__key_in_object(this_config, 'y')) {
-//                 let x = ndframe[this_config['x']].values
-//                 let y = ndframe[this_config['y']].values
-
-//                 let trace = {
-//                     x: x,
-//                     y: y,
-//                     type: config["kind"],
-//                     mode: config["mode"],
-//                 }
-
-//                 let xaxis = {}; let yaxis = {}
-//                 xaxis['title'] = this_config['x']
-//                 yaxis['title'] = this_config['y']
-
-//                 this_config['layout']['xaxis'] = xaxis
-//                 this_config['layout']['yaxis'] = yaxis
-
-
-//                 newPlot(div, [trace], this_config['layout']);
-
-//             } else {
-//                 //plot all
-//                 let y = ndframe.index
-//                 let data = []
-//                 ndframe.column_names.forEach(c_name => {
-//                     let trace = {
-//                         x: ndframe[c_name].values,
-//                         y: y,
-//                         type: this_config["kind"],
-//                         mode: this_config["mode"],
-//                         name: c_name
-//                     };
-//                     data.push(trace)
-
-//                 })
-//                 newPlot(div, data, this_config['layout']);
-//             }
-
-
-//         }
-//     }
-
-// }
+//perform plotting
+import { newPlot } from 'plotly.js/dist/plotly'
+import { Utils } from "../core/utils"
+import { Series } from "../core/series"
+
+const utils = new Utils()
+
+
+
+/**
+ * Plotting methods and Functions performed on Series and DataFrames
+ */
+export class Plot {
+    constructor() { }
+
+    plot(ndframe, div, config) {
+        let params = Object.keys(config)
+        let this_config = {}
+
+        params.forEach(param => {
+            this_config[param] = config[param]
+        })
+
+        if (!utils.__key_in_object(config, "layout")) {
+            this_config['layout'] = {}
+        }
+
+        if (ndframe instanceof Series) {
+            let trace = {}
+
+            if (this_config['type'] == 'histogram') {
+                let x = ndframe.values
+                trace["x"] = x
+            } else {
+                let y = ndframe.values
+                trace["y"] = y
+            }
+
+            params.forEach(param => {
+                trace[param] = config[param]
+            })
+            newPlot(div, [trace], this_config['layout']);
+
+        } else {
+
+            //DataFrame
+            if (utils.__key_in_object(this_config, 'x') && utils.__key_in_object(this_config, 'y')) {
+                if (!ndframe.column_names.includes(this_config['x'])) {
+                    throw Error(`Column Error: ${this_config['x']} not found in columns`)
+                }
+                if (!ndframe.column_names.includes(this_config['y'])) {
+                    throw Error(`Column Error: ${this_config['y']} not found in columns`)
+                }
+
+
+                let x = ndframe[this_config['x']].values
+                let y = ndframe[this_config['y']].values
+
+                let trace = {
+                    x: x,
+                    y: y,
+                    type: config["type"],
+                    mode: config["mode"],
+                }
+
+                let xaxis = {}; let yaxis = {}
+                xaxis['title'] = this_config['x']
+                yaxis['title'] = this_config['y']
+
+                this_config['layout']['xaxis'] = xaxis
+                this_config['layout']['yaxis'] = yaxis
+
+
+                newPlot(div, [trace], this_config['layout']);
+
+
+            } else if (this_config['type'] == 'pie') {
+                if (!ndframe.column_names.includes(this_config['values'])) {
+                    throw Error(`Column Error: ${this_config['values']} not found in columns`)
+                }
+                if (!ndframe.column_names.includes(this_config['labels'])) {
+                    throw Error(`Column Error: ${this_config['labels']} not found in columns`)
+                }
+                let data = [{
+                    values: ndframe[this_config['values']].values,
+                    labels: ndframe[this_config['labels']].values,
+                    type: 'pie'
+                }];
+
+                newPlot(div, data, this_config['layout'])
+
+            } else if (this_config['type'] == 'table') {
+                let header = {}
+                let cells = {}
+
+                header['values'] = ndframe.column_names
+                cells['values'] = ndframe.col_data
+
+                if (this_config['header_style']) {
+                    Object.keys(this_config['header_style']).forEach(param => {
+                        header[param] = this_config['header_style'][param]
+                    })
+                }
+
+                if (this_config['cell_style']) {
+                    Object.keys(this_config['cell_style']).forEach(param => {
+                        header[param] = this_config['cell_style'][param]
+                    })
+                }
+                var data = [{
+                    type: 'table',
+                    header: header,
+                    cells: cells
+                }]
+                newPlot(div, data, this_config['layout']);
+
+            } else if (this_config['type'] == 'box') {
+                let cols_2_show = []
+                let data = []
+
+                if (this_config['columns'] != undefined) {
+                    cols_2_show = this_config['columns']
+                    cols_2_show.forEach(col => {
+                        if (!ndframe.column_names.includes(col)) {
+                            throw Error(`Column Error: ${this_config['labels']} not found in columns`)
+                        }
+                    })
+                } else {
+                    cols_2_show = ndframe.column_names
+                }
+
+
+                cols_2_show.forEach(col => {
+                    let col_idx = ndframe.column_names.indexOf(col)
+                    let trace = []
+                    trace['y'] = ndframe.col_data[col_idx]
+                    trace["type"] = 'box'
+                    trace["name"] = col
+
+                    data.push(trace)
+                })
+                newPlot(div, data, this_config['layout']);
+
+            } else {
+                //plot all
+                let x = ndframe.index
+                let data = []
+                ndframe.column_names.forEach(c_name => {
+                    let trace = {}
+                    trace["x"] = x
+                    trace["y"] = ndframe[c_name].values
+                    trace['name'] = c_name
+                    params.forEach(param => {
+                        trace[param] = config[param]
+                    })
+                    data.push(trace)
+
+                })
+                newPlot(div, data, this_config['layout']);
+            }
+
+
+        }
+    }
+
+}