cheap-pandas/DataFrame.js

Not a good pandas library to use

const { shuffle } = require("shuffle-seed");
const { takeNSpace, toFixed4Digit } = require("./lib");

class DataFrame {
  constructor(
    columns = [],
    data = [],
    indexes = [],
    options = {
      printSpace: 20,
      customPrintSpaces: [],
    }
  ) {
    this.columns = columns;
    this.indexes = indexes;
    this.is_single_column;
    this.printSpace = options.printSpace;
    this.customPrintSpaces = options.customPrintSpaces;
    if (this.columns.length > 1) {
      let arr = [];
      for (let i = 0; i < columns.length; i++) {
        let col = [];
        for (let j = 0; j < data.length; j++) {
          col.push(data[j][i]);
        }
        arr.push(new DataFrame([columns[i]], col, indexes));
      }
      this.data = arr;
      this.is_single_column = false;
    } else {
      this.data = data;
      this.is_single_column = true;
    }
  }

  describe() {}

  min() {
    let s = `Min Value${this.is_single_column ? "" : "s"}`;
  }

  columnByName(name) {
    if (!this.columns.includes(name)) throw new Error("Such column not Found!");
    let columnIndex = this.columns.findIndex((c) => c === name);
    return this.data[columnIndex];
  }

  print() {
    if (this.is_single_column) {
      console.log(
        "_".repeat((1 + this.columns.length) * (this.printSpace + 1)) + "_"
      );
      let str =
        takeNSpace("index", this.printSpace) +
        this.columns.map((c) => takeNSpace(c, this.printSpace)).join("") +
        "|\n";
      str +=
        "|" +
        "-".repeat((1 + this.columns.length) * (this.printSpace + 1) - 1) +
        "|\n";
      for (let i = 0; i < this.indexes.length; i++) {
        str +=
          takeNSpace(this.indexes[i], this.printSpace) +
          takeNSpace(this.data[i], this.printSpace) +
          "|\n";
      }
      console.log(str);
    } else {
      console.log(
        "_".repeat((1 + this.columns.length) * (this.printSpace + 1)) + "_"
      );
      let str =
        takeNSpace("index", this.printSpace) +
        this.columns.map((c) => takeNSpace(c, this.printSpace)).join("") +
        "|\n";
      str +=
        "|" +
        "-".repeat((1 + this.columns.length) * (this.printSpace + 1) - 1) +
        "|\n";
      for (let i = 0; i < this.indexes.length; i++) {
        str +=
          takeNSpace(this.indexes[i], this.printSpace) +
          this.data
            .map((d) => takeNSpace(d.data[i], this.printSpace))
            .join("") +
          "|\n";
      }
      console.log(str);
    }
  }

  shuffle(seed) {
    if (!seed) {
      seed = Math.random();
    }
    if (!this.is_single_column) {
      this.indexes = shuffle(this.indexes, seed);
      this.data.forEach((d) => d.shuffle(seed));
    } else {
      this.data = shuffle(this.data, seed);
    }
  }

  head(n) {
    if (isNaN(n)) {
      n = 5;
    }
    if (!this.is_single_column) {
      let newDataFrame = new DataFrame([], [], []);
      newDataFrame.columns = this.columns;
      newDataFrame.data = this.data.map((d) => d.head(n));
      newDataFrame.indexes = this.indexes.slice(0, n);
      newDataFrame.is_single_column = false;
      return newDataFrame;
    } else {
      let newDataFrame = new DataFrame(
        this.columns,
        this.data.slice(0, n),
        this.indexes.slice(0, n)
      );
      return newDataFrame;
    }
  }
  tail(n) {
    if (isNaN(n)) {
      n = 5;
    }
    if (!this.is_single_column) {
      let newDataFrame = new DataFrame([], [], []);
      newDataFrame.columns = this.columns;
      newDataFrame.data = this.data.map((d) => d.tail(n));
      newDataFrame.indexes = this.indexes.slice(
        Math.max(0, this.indexes.length - n),
        this.indexes.length
      );
      newDataFrame.is_single_column = false;
      return newDataFrame;
    } else {
      let newDataFrame = new DataFrame(
        this.columns,
        this.data.slice(
          Math.max(0, this.indexes.length - n),
          this.indexes.length
        ),
        this.indexes.slice(
          Math.max(0, this.indexes.length - n),
          this.indexes.length
        )
      );
      return newDataFrame;
    }
  }
  groupby(column) {
    const columnIndex = this.columns.findIndex((c) => c === column);
    if (columnIndex === -1) throw new Error("Invalid Column");
    let set = new Set();
    let data = this.data[columnIndex].data;
    for (let i = 0; i < data.length; i++) {
      set.add(data[i]);
    }
    if (set.size > 300) {
      throw new Error("There are too many");
    }
    if (this.is_single_column) {
    } else {
      let groupObject = {};
      for (let i = 0; i < this.indexes.length; i++) {
        let element = this.data[columnIndex].data[i];
        if (!groupObject[element]) {
          groupObject[element] = new DataFrame(this.columns, [], []);
          groupObject[element].data = this.head(0).data;
        }
        groupObject[element].data.forEach((d, index) =>
          d.data.push(this.data[index].data[i])
        );
        groupObject[element].indexes.push(this.indexes[i]);
      }
      return groupObject;
    }
  }
  getRow(n) {
    if (this.is_single_column) {
      return this.data[n - 1];
    } else {
      return this.data.map((d) => d.getRow(n));
    }
  }
}

module.exports = DataFrame;