tensor and table support

Author: lidangzzz

packages/hedgehog-core/.eslintrc

@@ -16,7 +16,8 @@
         "bracketSpacing": true,
         "jsxBracketSameLine": true,
         "alwaysParens":"avoid",
-        "@typescript-eslint/ban-ts-ignore": "off"
+        "@typescript-eslint/ban-ts-ignore": "off",
+        "endOfLine": "auto"
       }
     ]
   }

packages/hedgehog-core/package.json

@@ -28,13 +28,14 @@
         "@tensorflow/tfjs": "^2.7.0",
         "babel-template": "^6.26.0",
         "clean-webpack-plugin": "^3.0.0",
+        "csv": "^5.5.0",
         "esbuild-loader": "^2.9.1",
         "gpu.js": "^2.9.5",
         "mathjs": "^7.1.0",
         "nerdamer": "^1.1.5",
+        "sync-fetch": "^0.3.0",
         "webpack": "^5.21.2",
-        "webpack-cli": "^4.5.0",
-        "sync-fetch": "^0.3.0"
+        "webpack-cli": "^4.5.0"
     },
     "devDependencies": {
         "@babel/types": "^7.10.5",

packages/hedgehog-core/src/index.ts

@@ -2,5 +2,6 @@ import { executeOutput } from './runtime';
 import transpile from './transpiler/transpiler-core';
 
 export * from './output/output-item';
+export * from './lib/table';
 
 export { executeOutput, transpile };

packages/hedgehog-core/src/lib/mathlib.ts

@@ -1,6 +1,6 @@
 import { Mat } from './matrix';
 
-function to_matrix(A: Mat | number[][] | number[] | number): Mat {
+function to_matrix(A: Mat | number[][] | number[] | number): Mat  {
   if (A instanceof Mat) {
     return A.clone();
   }

packages/hedgehog-core/src/lib/matrix.ts

@@ -602,7 +602,7 @@ export class Mat {
     let ret = 0;
     for (let i = 0; i < this.rows; i++) {
       for (let j = 0; j < this.cols; j++) {
-        let val = this.val[i][j];
+        const val = this.val[i][j];
         ret += val * val;
       }
     }

packages/hedgehog-core/src/lib/random.ts

@@ -0,0 +1,89 @@
+/*
+  Table is the data tructure that's designed for tabular data 
+  such as CSV file or matrix in CSV format as data frame
+*/
+
+import * as csv from 'csv/lib/sync';
+
+export class Table {
+  // 2D string contains the table cells
+  cells: string[][];
+
+  // row number
+  rows: number;
+
+  // column number
+  cols: number;
+
+  // array of string that contains header cells
+  headers: string[];
+
+  // containsHeaders is true if this table contains headers
+  containsHeaders: boolean;
+
+  /* The constructor contains three parameters: 
+    1. input a. raw csv string or b. 2-D string array as the raw data
+    2. boolean header? if it contains headers
+  */
+  constructor(input?: string | string[][] | Table, header?: boolean) {
+    if (header === undefined) {
+      this.containsHeaders = false;
+    } else {
+      this.containsHeaders = header;
+    }
+    this.cells = new Array(0);
+    this.rows = 0;
+    this.cols = 0;
+    this.headers = new Array(0);
+    if (typeof input === 'string') {
+      const records = (csv.parse as any)(input, {
+        columns: false,
+        skip_empty_lines: true,
+        quote: '"',
+        ltrim: true,
+        rtrim: true,
+        delimiter: ','
+      });
+      this.cells = records;
+      this.rows = records.length;
+      this.cols = this.rows === 0 ? 0 : records[0].length;
+    } else if (input instanceof Array) {
+      this.cells = input;
+      this.rows = input.length;
+      this.cols = this.rows === 0 ? 0 : input[0].length;
+      this.headers = new Array(0);
+    }
+
+    // craete headers if it exists
+    if (this.containsHeaders === true) {
+      // fetch the first array in cells into headers
+      if (this.cells.length > 1) {
+        this.headers = this.cells[0];
+        const newCells: string[][] = [];
+        for (let idx = 1; idx < this.cells.length; idx++) {
+          newCells.push(this.cells[idx]);
+        }
+        this.cells = newCells;
+      } else {
+        throw 'If "containsHeaders" is set as true, the table must contains at least one row.';
+      }
+    }
+  }
+
+  /**
+   * Insert a new row (array of string) at the end of table.
+   */
+  insert(newTuple: string[]) {
+    if (newTuple.length === this.cols) {
+      this.cells.push(newTuple);
+    } else {
+      throw (
+        'The length of new tuple inserting to the table is ' +
+        newTuple.length +
+        ' but the columns of table is ' +
+        this.cols +
+        '. Please make  sure that they are with the same length.'
+      );
+    }
+  }
+}

packages/hedgehog-core/src/lib/table.ts

@@ -0,0 +1,131 @@
+// The class for tensor, n-dimensional array
+
+export class Tensor {
+  // val is an n-d array
+  val: any[];
+  // ndim is the number of dimensions.
+  ndim: number;
+  // shape is the array of number that contains the length of each dimension
+  shape: number[];
+
+  //constructor of tensor classes
+  constructor(input?: any[] | number) {
+    this.val = [];
+    this.ndim = 0;
+    this.shape = [];
+    if (typeof input === 'number') {
+      this.val = [input];
+    } else if (input !== undefined) {
+      this.val = input;
+    }
+    this.initializeDimensions();
+  }
+
+  /* initializeDimensions() function will check:
+      1. The length of each dimension;
+      2. Initialize the shape[] array of current tensor
+  */
+  initializeDimensions(){
+    let result:number[] = [];
+    let currentDimensionPt = 0;
+    let pt = this.val;
+    while (pt instanceof Array) {
+      currentDimensionPt += 1;
+      result.push(pt.length);
+      pt = pt[0];
+    }
+    this.shape = result;
+    this.ndim = result.length;
+  }
+
+  // return the list of each dimension
+  dimensions(): number[] {
+    return this.shape;
+  }
+
+  /* return the string of this tensor in which each 2D array is 
+     formatted as a 2D matrix
+     for example:
+     [[[...],
+      [...]],
+      ...
+     ]
+  */
+  toString(): string {
+    return JSON.stringify(this.val).split('],').join('],\n').split(']],').join(']],\n');
+  }
+
+  /* return the string of this tensor in matrix format,
+     which looks like the stringify 2D array
+     for example:  [[[...],[...]],[[...],[...]]]
+  */
+  toStringDenseMode(): string {
+    return JSON.stringify(this.val);
+  }
+
+  log(): Tensor {
+    console.log(this);
+    return this;
+  }
+
+  /* 
+      Deep clone current tensor into another Tensor object 
+      Todo: implement a more efficient way to clone
+  */
+  clone() : Tensor {
+    return JSON.parse(JSON.stringify(this))
+  }
+
+  // Deep copy tensor A into this object
+  copy(A:Tensor) : Tensor {
+    const result = A.clone()
+    this.val = result.val;
+    this.ndim = result.ndim;
+    this.shape = result.shape;
+    return this;
+  }
+
+  // TODO: Initialize a zero tensor in "shape"
+  zerosAsShape(shape: number[]) : Tensor {
+    let returnTensor = new Tensor();
+    let currentSubTensor = [];
+    return returnTensor;
+  }
+
+  /*
+  Todo: zeros function
+  */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  zeros(a0?:number,a1?:number,a2?:number,a3?:number,a4?:number,a5?:number,a6?:number,a7?:number,a8?:number,a9?:number,a10?:number,a11?:number,a12?:number,a13?:number,a14?:number,a15?:number) : Tensor {
+    let returnTensor = new Tensor();
+    let shape:number[] = [];
+    for (let i=0;i<16;i++){
+      // eslint-disable-next-line prefer-rest-params
+      if (arguments[i] !== undefined) {
+        if (arguments[i] === 0) {
+          throw 'The dimension of the initialized zeros tensor cannot be zero.';
+        }
+        // eslint-disable-next-line prefer-rest-params
+        shape.push(arguments[i]);
+      }
+    }
+    return returnTensor;
+  }
+
+  /*
+  Todo list:
+  1. Constructor for certain types of tensor, such as ones, random
+  2. Operators for tensors
+  3. GPU operators for tensors
+  */
+   
+}
+
+export function tensor2json(A: Tensor): string {
+  return JSON.stringify(A);
+}
+
+export function json2tensor(json_str: string): Tensor {
+  const obj = JSON.parse(json_str);
+  return new Tensor(obj.val);
+}

packages/hedgehog-core/src/lib/tensor.ts

@@ -4,6 +4,8 @@
 // or a tuple of data and layout (into a figure of plotlyjs)
 // and type is a string of "TEXT" or "DRAWING" or "TEX" or "FORMULA"
 
+import { Table } from '../lib/table';
+
 export type TextItem = {
   itemType: 'TEXT';
   text: string;
@@ -19,6 +21,15 @@ export type DrawingItem = {
   layout: any;
 };
 
+export type TableItem = {
+  itemType: 'TABLE';
+  table: Table;
+};
+
+export const isTableItem = (item: OutputItem) : item is TableItem => {
+  return item.itemType === 'TABLE';
+};
+
 export const isDrawingItem = (item: OutputItem): item is DrawingItem => {
   return item.itemType === 'DRAWING';
 };
@@ -50,4 +61,6 @@ export const isMarkdownItem = (item: OutputItem): item is MarkdownItem => {
   return item.itemType === 'MARKDOWN';
 };
 
-export type OutputItem = TextItem | DrawingItem | TeXItem | FormulaItem | MarkdownItem;
+export type OutputItem = TextItem | DrawingItem | TeXItem | FormulaItem | MarkdownItem | TableItem;
+
+

packages/hedgehog-core/src/output/output-item.ts

@@ -14,16 +14,13 @@ export function executeOutput(code: string) {
   }
 
   // eslint-disable-next-line no-new-func
-  const fn = new Function(
-    'prelude',
-    preludeImport + code + '\n return _OUTPUT_ITEMS_LIST_;'
-  );
+  const fn = new Function('prelude', preludeImport + code + '\n return _OUTPUT_ITEMS_LIST_;');
 
   const results = fn.call({}, prelude);
 
-  console.log('Execution results:');
+  console.log('***Execution results***');
   console.log(results);
-  console.log('-- End of execution results:');
+  console.log('***End of execution results***');
 
   const returnList = [...results];
   prelude._OUTPUT_ITEMS_LIST_.length = 0;