SYMBOL INDEX (394 symbols across 46 files)

FILE: cv/image_filter/cavin.js
  function Features2D (line 289) | function Features2D() {}
  function Util (line 308) | function Util() {}

FILE: cv/image_filter/cvsandbox.js
  function CV (line 6) | function CV() {

FILE: cv/lsd/line-segment-detector/src/funcs.ts
  constant M_3_2_PI (line 7) | const M_3_2_PI = (3 * Math.PI) / 2;
  constant M_2__PI (line 8) | const M_2__PI = (2 * Math.PI);
  constant M_LN10 (line 9) | const M_LN10 = 2.30258509299404568402;
  constant NOT_DEF (line 10) | const NOT_DEF = -1024.0;
  constant USED (line 11) | const USED = 1;
  constant NOT_USED (line 12) | const NOT_USED = 0;
  constant RELATIVE_ERROR_FACTOR (line 13) | const RELATIVE_ERROR_FACTOR = 100.0;
  constant DEG_TO_RADS (line 14) | const DEG_TO_RADS = Math.PI / 180;
  constant REFINE_NONE (line 15) | const REFINE_NONE = 0;
  constant REFINE_STD (line 16) | const REFINE_STD = 1;
  constant REFINE_ADV (line 17) | const REFINE_ADV = 2;
  function logGammaLanczos (line 26) | function logGammaLanczos(x: number) {
  function angleDiffSigned (line 46) | function angleDiffSigned(a: number, b: number) {
  function angleDiff (line 58) | function angleDiff(a: number, b: number) {
  function doubleEqual (line 63) | function doubleEqual(a: number, b: number) {
  function AsmallerB_XoverY (line 79) | function AsmallerB_XoverY(a: Edge, b: Edge) {

FILE: cv/lsd/line-segment-detector/src/lsd.ts
  class LSD (line 27) | class LSD {
    method constructor (line 37) | constructor(
    method detect (line 46) | detect(image: ImageData) {
    method drawSegments (line 59) | drawSegments(context: CanvasRenderingContext2D, lines: Vec4[], color =...
    method putImageData (line 75) | putImageData(context: CanvasRenderingContext2D) {
    method lsd (line 92) | lsd() {
    method computeLevelLineAngles (line 162) | computeLevelLineAngles(threshold: number, nBins: number) {
    method regionGrow (line 236) | regionGrow(s: Point, reg: RegionPoint[], regAngle: number, prec: numbe...
    method isAligned (line 278) | isAligned(x: number, y: number, theta: number, prec: number) {
    method region2Rect (line 299) | region2Rect(reg: RegionPoint[], regAngle: number, prec: number, p: num...
    method getTheta (line 350) | getTheta(reg: RegionPoint[], x: number, y: number, regAngle: number, p...
    method refine (line 377) | refine(reg: RegionPoint[], regAngle: number, prec: number, p: number, ...
    method reduceRegionRadius (line 412) | reduceRegionRadius(reg: RegionPoint[], regAngle: number, prec: number,...
    method improveRect (line 440) | improveRect(rect: Rect) {
    method rectNfa (line 508) | rectNfa(rect: Rect) {
    method nfa (line 615) | nfa(n: number, k: number, p: number) {
    method gaussianBlur (line 652) | gaussianBlur(imageData: Uint8ClampedArray, kSize: number, sigma: numbe...
    method getGaussianKernel (line 706) | getGaussianKernel(kSize: number, sigma: number) {
    method reshape (line 724) | reshape(image: ImageData) {
    method at (line 734) | at(data: Uint8Array|Float64Array, p: Point) {
    method row (line 738) | row(data: Float64Array, rowIndex: number) {
    method setRow (line 743) | setRow(data: Float64Array, index: number, value: number) {
    method setCol (line 752) | setCol(data: Float64Array, index: number, value: number) {

FILE: cv/lsd/line-segment-detector/src/types.ts
  class Vec4 (line 1) | class Vec4 {
    method constructor (line 2) | constructor(public x1 = 0, public y1 = 0, public x2 = 0, public y2 = 0...
  class Point (line 5) | class Point {
    method constructor (line 6) | constructor(public x = 0.0, public y = 0.0) { }
  class CoorList (line 9) | class CoorList {
    method constructor (line 13) | constructor() {
  class RegionPoint (line 18) | class RegionPoint {
    method constructor (line 19) | constructor(public x = 0, public y = 0, public angle = 0.0, public mod...
  class Rect (line 22) | class Rect {
    method constructor (line 23) | constructor(
    method copy (line 29) | copy(rect: Rect) {
  class Edge (line 46) | class Edge {
    method constructor (line 50) | constructor() {

FILE: cv/lsd/src/funcs.js
  constant M_3_2_PI (line 5) | const M_3_2_PI = (3 * Math.PI) / 2;
  constant M_2__PI (line 6) | const M_2__PI = (2 * Math.PI);
  constant M_LN10 (line 7) | const M_LN10 = 2.30258509299404568402;
  constant NOT_DEF (line 8) | const NOT_DEF = -1024.0;
  constant USED (line 9) | const USED = 1;
  constant NOT_USED (line 10) | const NOT_USED = 0;
  constant RELATIVE_ERROR_FACTOR (line 11) | const RELATIVE_ERROR_FACTOR = 100.0;
  constant DEG_TO_RADS (line 12) | const DEG_TO_RADS = Math.PI / 180;
  constant REFINE_NONE (line 13) | const REFINE_NONE = 0;
  constant REFINE_STD (line 14) | const REFINE_STD = 1;
  constant REFINE_ADV (line 15) | const REFINE_ADV = 2;
  function logGammaLanczos (line 24) | function logGammaLanczos(x) {
  function angleDiffSigned (line 50) | function angleDiffSigned(a, b) {
  function angleDiff (line 67) | function angleDiff(a, b) {
  function doubleEqual (line 77) | function doubleEqual(a, b) {
  function AsmallerB_XoverY (line 98) | function AsmallerB_XoverY(a, b) {

FILE: cv/lsd/src/lsd.js
  class LSD (line 27) | class LSD {
    method constructor (line 28) | constructor(
    method detect (line 62) | detect(image) {
    method drawSegments (line 75) | drawSegments(context, lines, color = '#ff0000') {
    method putImageData (line 91) | putImageData(context) {
    method lsd (line 107) | lsd() {
    method computeLevelLineAngles (line 177) | computeLevelLineAngles(threshold, nBins) {
    method regionGrow (line 256) | regionGrow(s, reg, regAngle, prec) {
    method isAligned (line 304) | isAligned(x, y, theta, prec) {
    method region2Rect (line 332) | region2Rect(reg, regAngle, prec, p, rect) {
    method getTheta (line 391) | getTheta(reg, x, y, regAngle, prec) {
    method refine (line 427) | refine(reg, regAngle, prec, p, rect, densityTh) {
    method reduceRegionRadius (line 471) | reduceRegionRadius(reg, regAngle, prec, p, rect, density, densityTh) {
    method improveRect (line 503) | improveRect(rect) {
    method rectNfa (line 575) | rectNfa(rect) {
    method nfa (line 684) | nfa(n, k, p) {
    method gaussianBlur (line 727) | gaussianBlur(imageData, kSize, sigma) {
    method getGaussianKernel (line 786) | getGaussianKernel(kSize, sigma) {
    method reshape (line 807) | reshape(image) {
    method at (line 821) | at(data, p) {
    method row (line 829) | row(data, rowIndex) {
    method setRow (line 840) | setRow(data, index, value) {
    method setCol (line 855) | setCol(data, index, value) {

FILE: cv/lsd/src/lsd_component.js
  class LSDComponent (line 5) | class LSDComponent extends React.Component {
    method constructor (line 6) | constructor(props) {
    method componentDidMount (line 10) | componentDidMount() {
    method componentDidUpdate (line 18) | componentDidUpdate() {
    method apply (line 21) | apply(e) {
    method reset (line 31) | reset(e) {
    method onLoad (line 36) | onLoad() {
    method render (line 44) | render() {

FILE: cv/lsd/src/types.js
  class Vec4 (line 1) | class Vec4 {
    method constructor (line 2) | constructor(x1 = 0, y1 = 0, x2 = 0, y2 = 0) {
  class Point (line 10) | class Point {
    method constructor (line 11) | constructor(x = 0.0, y = 0.0) {
  class CoorList (line 17) | class CoorList {
    method constructor (line 18) | constructor() {
  class RegionPoint (line 25) | class RegionPoint {
    method constructor (line 26) | constructor(x = 0, y = 0, angle = 0.0, modgrad = 0.0, used = null) {
  class Rect (line 36) | class Rect {
    method constructor (line 37) | constructor(
    method copy (line 59) | copy(rect) {
  class Edge (line 76) | class Edge {
    method constructor (line 77) | constructor() {

FILE: cv/pixel_clustering/kmeans.js
  function kmeans (line 8) | function kmeans(samples, ncluster, method) {
  function vq (line 135) | function vq(samples, centroids, code) {

FILE: cv/stereo_matching/stereo-core.js
  function findStereoCorrespondence (line 5) | function findStereoCorrespondence(pair, state) {

FILE: cv/utils/histogram.js
  function self (line 7) | function self() {

FILE: draw/lib3d.js
  function self (line 8) | function self() {

FILE: draw/webgl/glsample.js
  function start (line 8) | function start() {
  function initWebGL (line 28) | function initWebGL(canvas) {

FILE: ml/arow/arow.ts
  class AROW (line 7) | class AROW {
    method constructor (line 13) | constructor(featureSize: number, r: number = 0.1) {
    method predict (line 21) | public predict(x: Feature): number {
    method clear (line 25) | public clear(): void {
    method update (line 31) | public update(x: Feature, label: number): number {
    method computeMargin (line 49) | private computeMargin(x: Feature): number {
    method computeConfidence (line 55) | private computeConfidence(x: Feature): number {

FILE: ml/arow/data_loader.ts
  class DataLoader (line 10) | class DataLoader {
    method data (line 16) | get data(): DataSet {
    method size (line 19) | get size(): number {
    method constructor (line 23) | constructor(filePath: string) {
    method parse (line 30) | private parse(): void {
    method read (line 48) | public static read(filePath: string, callback: Function, complete: Fun...

FILE: ml/arow/out/arow.js
  function AROW (line 3) | function AROW(featureSize, r) {

FILE: ml/arow/out/data_loader.js
  function DataLoader (line 5) | function DataLoader(filePath) {

FILE: ml/arow/types.ts
  type Feature (line 4) | type Feature = { index: number, value: number }[];
  type DataSet (line 5) | type DataSet = { label: number, x: Feature }[];

FILE: ml/autoencoder/out/da.js
  function DenoisingAutoencoders (line 8) | function DenoisingAutoencoders(input, nVisible, nHidden, W, vBias, hBias...

FILE: ml/autoencoder/out/matrix.js
  function Matrix (line 8) | function Matrix(elements) {

FILE: ml/autoencoder/out/vector.js
  function Vector (line 7) | function Vector(elements) {

FILE: ml/autoencoder/src/controller.ts
  type dA (line 4) | type dA = ml.DenoisingAutoencoders;
  type Scope (line 6) | interface Scope extends ng.IScope {
  class Controller (line 26) | class Controller {
    method constructor (line 38) | constructor(private $scope: Scope,
    method train (line 72) | public train(): void {
    method loadModel (line 112) | public loadModel(): void {
    method saveModel (line 125) | public saveModel(): void {
    method deleteModel (line 132) | public deleteModel(): void {
    method createContext (line 139) | private createContext(): CanvasRenderingContext2D {
    method drawGraph (line 151) | private drawGraph(): void {

FILE: ml/autoencoder/src/da.ts
  type dA (line 6) | type dA = ml.DenoisingAutoencoders;
  type f (line 7) | type f = (x: number) => number;
  type Model (line 9) | interface Model {
  class DenoisingAutoencoders (line 13) | class DenoisingAutoencoders implements Model {
    method constructor (line 14) | constructor(private input: Matrix, private nVisible: number, private n...
    method weights (line 22) | get weights(): Matrix { return this.W; }
    method weights (line 23) | set weights(w: Matrix) { this.W = w; }
    method vbias (line 24) | get vbias(): Vector { return this.vBias; }
    method vbias (line 25) | set vbias(b: Vector) { this.vBias = b; }
    method hbias (line 26) | get hbias(): Vector { return this.hBias; }
    method hbias (line 27) | set hbias(b: Vector) { this.hBias = b; }
    method data (line 28) | get data(): Matrix { return this.input; }
    method data (line 29) | set data(input: Matrix) { this.input = input; }
    method time (line 30) | get time(): number { return this.timestamp; }
    method train (line 35) | public train(learningRate: number, corruptionLevel: number): void {
    method reconstruct (line 61) | public reconstruct(matrix: Matrix): Matrix {
    method getCost (line 69) | public getCost(corruptionLevel: number): number {
    method updateTimestamp (line 84) | public updateTimestamp(): void {
    method convertModel (line 89) | public convertModel(value: any): [dA, Date] {
    method getCorruptedInput (line 100) | private getCorruptedInput(input: Matrix, corruptionLevel: number): Mat...
    method getHiddenValues (line 118) | private getHiddenValues(input: Matrix): Matrix {
    method getReconstructedInput (line 125) | private getReconstructedInput(hidden: Matrix): Matrix {
    method binomial (line 131) | private binomial(n: number, p: number): number {

FILE: ml/autoencoder/src/matrix.ts
  class Matrix (line 5) | class Matrix {
    method constructor (line 8) | constructor(elements: number[][]) {
    method shape (line 12) | get shape(): number[] {
    method rows (line 16) | get rows(): number { return this.elements.length; }
    method cols (line 17) | get cols(): number { return this.elements[0].length; }
    method rand (line 19) | static rand(n: number, m: number, round: boolean = false): Matrix {
    method zeros (line 28) | static zeros(n: number, m: number): Matrix {
    method ones (line 32) | static ones(n: number, m: number): Matrix {
    method fill (line 36) | static fill(n: number, m: number, x: number): Matrix {
    method row (line 48) | public row(i: number): Vector {
    method col (line 55) | public col(j: number): Vector {
    method at (line 68) | public at(i: number, j: number): number {
    method add (line 76) | public add(matrix: Matrix): Matrix {
    method subtract (line 83) | public subtract(matrix: Matrix): Matrix {
    method isSameSizeAs (line 90) | private isSameSizeAs(matrix: Matrix): boolean {
    method multiply (line 95) | public multiply(matrix: number | Matrix): Matrix { // Jasmine not supp...
    method dot (line 116) | public dot(matrix: Matrix): Matrix {
    method transpose (line 144) | public transpose(): Matrix {
    method addBias (line 159) | public addBias(bias: Vector): Matrix {
    method sum (line 175) | public sum(axis: number = 0): Vector {
    method mean (line 202) | public mean(axis: number = 0): Vector {
    method max (line 212) | public max(): number {
    method log (line 227) | public log(): Matrix {
    method map (line 231) | public map(fn: Function): Matrix {
    method toString (line 246) | public toString(round: boolean = false): string {
    method setElements (line 261) | private setElements(elements: number[][]) {

FILE: ml/autoencoder/src/matrix_t.ts
  class MatrixT (line 5) | class MatrixT {
    method constructor (line 11) | constructor(elements: any) {
    method shape (line 20) | get shape(): number[] {
    method rows (line 24) | get rows(): number { return this.elements.length; }
    method cols (line 25) | get cols(): number { return this.elements[0].length; }
    method rand (line 27) | static rand(n: number, m: number): MatrixT {
    method zeros (line 31) | static zeros(n: number, m: number): MatrixT {
    method row (line 43) | public row(i: number): VectorT {
    method col (line 50) | public col(j: number): VectorT {
    method at (line 63) | public at(i: number, j: number): number {
    method add (line 70) | public add(matrix: MatrixT): MatrixT {
    method subtract (line 77) | public subtract(matrix: MatrixT): MatrixT {
    method isSameSizeAs (line 84) | private isSameSizeAs(matrix: MatrixT): boolean {
    method multiply (line 90) | public multiply(matrix): MatrixT {
    method dot (line 110) | public dot(matrix): MatrixT {
    method transpose (line 138) | public transpose(): MatrixT {
    method addBias (line 153) | public addBias(bias: VectorT): MatrixT {
    method sum (line 169) | public sum(axis: number = 0): VectorT {
    method mean (line 196) | public mean(axis: number = 0): VectorT {
    method log (line 223) | public log(): MatrixT {
    method map (line 227) | public map(fn: Function): MatrixT {
    method toString (line 242) | public toString(round: boolean = false): string {
    method setElements (line 257) | private setElements(elements: number[][]) {

FILE: ml/autoencoder/src/storage.ts
  class ModelStorage (line 6) | class ModelStorage {
    method constructor (line 8) | constructor(private name: string, private version: number) {
    method upgrade (line 14) | private upgrade(e: any): void {
    method load (line 20) | public load(callback: (data: Object) => void): void {
    method add (line 40) | public add(model: Model, callback: () => void): void {
    method delete (line 59) | public delete(callback: () => void): void {

FILE: ml/autoencoder/src/vector.ts
  class Vector (line 5) | class Vector {
    method constructor (line 7) | constructor(private elements: number[]) { }
    method size (line 9) | get size(): number { return this.elements.length; }
    method create (line 11) | static create(elements: number[]): Vector {
    method rand (line 15) | static rand(n: number): Vector {
    method zeros (line 21) | static zeros(n: number): Vector {
    method arange (line 27) | static arange(n: number): Vector {
    method clone (line 35) | public clone(): Vector {
    method at (line 39) | public at(i: number): number {
    method add (line 44) | public add(vector: Vector): Vector {
    method subtract (line 50) | public subtract(vector: Vector): Vector {
    method multiply (line 56) | public multiply(k: number): Vector {
    method dot (line 60) | public dot(vector: Vector): number {
    method cross (line 73) | public cross(vector: Vector): Vector {
    method mean (line 86) | public mean(): number {
    method toString (line 95) | public toString(): string {
    method map (line 99) | public map(fn: Function): Vector {
    method forEach (line 105) | private forEach(fn: Function): void {

FILE: ml/autoencoder/src/vector_t.ts
  class VectorT (line 5) | class VectorT {
    method constructor (line 10) | constructor(elements: any) {
    method size (line 19) | get size(): number { return this.elements.length; }
    method create (line 21) | static create(elements: Float32Array): VectorT {
    method rand (line 25) | static rand(n: number): VectorT {
    method zeros (line 33) | static zeros(n: number): VectorT {
    method arange (line 37) | static arange(n: number): VectorT {
    method clone (line 45) | public clone(): VectorT {
    method at (line 49) | public at(i: number): number {
    method add (line 54) | public add(vector: VectorT): VectorT {
    method subtract (line 60) | public subtract(vector: VectorT): VectorT {
    method multiply (line 66) | public multiply(k: number): VectorT {
    method dot (line 70) | public dot(vector: VectorT): number {
    method cross (line 83) | public cross(vector: VectorT): VectorT {
    method mean (line 96) | public mean(): number {
    method toString (line 105) | public toString(): string {
    method map (line 117) | public map(fn: Function, size: number): VectorT {
    method forEach (line 123) | private forEach(fn: Function): void {

FILE: ml/gbdt/src/gradient_boosting.js
  class GradientBoostingRegressor (line 8) | class GradientBoostingRegressor {
    method constructor (line 15) | constructor(nEstimators = 100, learningRate = 0.1, depth = 3, lossFunc...
    method fit (line 35) | fit(x, y) {
    method predict (line 52) | predict(x) {

FILE: ml/gbdt/src/metrics.js
  function mse (line 7) | function mse(test, pred) {
  function rmse (line 22) | function rmse(test, pred) {
  function score (line 32) | function score(test, pred) {
  function residual (line 42) | function residual(test, pred) {
  function variance (line 57) | function variance(data) {

FILE: ml/gbdt/src/regression_tree.js
  class RegressionTree (line 1) | class RegressionTree {
    method constructor (line 5) | constructor(depth) {
    method fit (line 19) | fit(x, y) {
    method predict (line 36) | predict(x) {
    method growTree (line 59) | growTree(id, x, y) {
    method searchBestSplit (line 88) | searchBestSplit(id, x, y) {
    method calculateImpurity (line 117) | calculateImpurity(j, threshold, id, x, y) {
  class Node (line 152) | class Node {
    method constructor (line 153) | constructor() {

FILE: ml/kmeans/kmeans.js
  function kmeans (line 8) | function kmeans(samples, ncluster, method) {
  function vq (line 135) | function vq(samples, centroids, code) {

FILE: ml/logistic_regression/logistic_regression.ts
  class LogisticRegression (line 5) | class LogisticRegression {
    method constructor (line 7) | constructor(private input: Matrix, private label: Matrix,
    method fit (line 13) | public fit(learningRate: number, iter: number, l2Reg: number = 0.00, v...
    method train (line 27) | public train(learningRate: number, l2Reg: number = 0.00): void {
    method predict (line 36) | public predict(x: Matrix): Matrix {
    method getLoss (line 41) | public getLoss(): number {
    method softmax (line 56) | private softmax(x: Matrix): Matrix {
    method softmax2 (line 74) | private softmax2(x: Matrix): Matrix {

FILE: ml/logistic_regression/matrix.ts
  class Matrix (line 5) | class Matrix {
    method constructor (line 8) | constructor(elements: number[][]) {
    method shape (line 12) | get shape(): number[] {
    method rows (line 16) | get rows(): number { return this.elements.length; }
    method cols (line 17) | get cols(): number { return this.elements[0].length; }
    method rand (line 19) | static rand(n: number, m: number, round: boolean = false): Matrix {
    method zeros (line 28) | static zeros(n: number, m: number): Matrix {
    method ones (line 32) | static ones(n: number, m: number): Matrix {
    method fill (line 36) | static fill(n: number, m: number, x: number): Matrix {
    method row (line 48) | public row(i: number): Vector {
    method col (line 55) | public col(j: number): Vector {
    method at (line 68) | public at(i: number, j: number): number {
    method add (line 76) | public add(matrix: Matrix): Matrix {
    method subtract (line 83) | public subtract(matrix: Matrix): Matrix {
    method isSameSizeAs (line 90) | private isSameSizeAs(matrix: Matrix): boolean {
    method multiply (line 95) | public multiply(matrix: number | Matrix): Matrix { // Jasmine not supp...
    method dot (line 116) | public dot(matrix: Matrix): Matrix {
    method transpose (line 144) | public transpose(): Matrix {
    method addBias (line 159) | public addBias(bias: Vector): Matrix {
    method sum (line 175) | public sum(axis: number = 0): Vector {
    method mean (line 202) | public mean(axis: number = 0): Vector {
    method max (line 212) | public max(): number {
    method log (line 227) | public log(): Matrix {
    method map (line 231) | public map(fn: Function): Matrix {
    method toString (line 246) | public toString(round: boolean = false): string {
    method setElements (line 261) | private setElements(elements: number[][]) {

FILE: ml/logistic_regression/vector.ts
  class Vector (line 5) | class Vector {
    method constructor (line 7) | constructor(public elements: number[]) { }
    method size (line 9) | get size(): number { return this.elements.length; }
    method create (line 11) | static create(elements: number[]): Vector {
    method rand (line 15) | static rand(n: number): Vector {
    method zeros (line 21) | static zeros(n: number): Vector {
    method arange (line 27) | static arange(n: number): Vector {
    method clone (line 35) | public clone(): Vector {
    method at (line 39) | public at(i: number): number {
    method add (line 44) | public add(vector: Vector): Vector {
    method subtract (line 50) | public subtract(vector: Vector): Vector {
    method multiply (line 56) | public multiply(k: number): Vector {
    method dot (line 60) | public dot(vector: Vector): number {
    method cross (line 73) | public cross(vector: Vector): Vector {
    method mean (line 86) | public mean(): number {
    method toString (line 95) | public toString(): string {
    method map (line 99) | public map(fn: Function): Vector {
    method forEach (line 105) | private forEach(fn: Function): void {

FILE: ml/scw/data_loader.ts
  class DataLoader (line 10) | class DataLoader {
    method data (line 16) | get data(): DataSet {
    method size (line 19) | get size(): number {
    method constructor (line 23) | constructor(filePath: string, featureSize: number = 0) {
    method parse (line 34) | private parse(): void {
    method parsePaddingZero (line 52) | private parsePaddingZero(featureSize: number): void {
    method read (line 68) | public static read(filePath: string, featureSize:number, callback: Fun...

FILE: ml/scw/out/data_loader.js
  function DataLoader (line 5) | function DataLoader(filePath, featureSize) {

FILE: ml/scw/out/scw.js
  function SCW (line 3) | function SCW(n, eta, C, type) {

FILE: ml/scw/scw.ts
  class SCW (line 4) | class SCW {
    method constructor (line 15) | constructor(n: number, eta:number, C:number, type: string = SCW.SCW_I) {
    method predict (line 31) | public predict(x: Float32Array): number {
    method update (line 35) | public update(x: Float32Array, y: number, verbose: boolean = false) {
    method loss (line 50) | public loss(x: Float32Array, y: number): number {
    method calculateAlpha (line 54) | private calculateAlpha(x: Float32Array, y: number, vt: number): number {
    method calculateBeta (line 78) | private calculateBeta(alpha: number, vt: number): number {
    method updateConfidence (line 87) | private updateConfidence(x: Float32Array): number { // vt
    method updateWeights (line 99) | private updateWeights(alpha: number, x: Float32Array, y: number): void {
    method updateCovariance (line 113) | private updateCovariance(beta: number, x: Float32Array): void {
    method normcdf (line 132) | private normcdf(x: number): number {
    method dot (line 147) | private dot(x: Float32Array, y: Float32Array): number {
    method prod (line 156) | private prod(m1: Float32Array[], m2: Float32Array[]): Float32Array[] {

FILE: ml/scw/types.ts
  type Feature (line 4) | type Feature = { index: number, value: number }[];
  type DataSet (line 5) | type DataSet = { label: number, x: Feature | Float32Array }[];

FILE: ml/t-sne/src/tsne.js
  class tSNE (line 8) | class tSNE {
    method constructor (line 14) | constructor(data, params) {
    method init (line 28) | init() {
    method compute (line 47) | async compute(iter) {
    method iterator (line 64) | *iterator(iter) {
    method stepGradient (line 83) | stepGradient(P, step, t) {
    method calculateCostGrad (line 120) | calculateCostGrad(Y, P, iter) {
    method computeP (line 153) | computeP() {
    method calculateEntropy (line 206) | calculateEntropy(probs, i) {
    method calculateProbs (line 225) | calculateProbs(D, sigma, i, P) {
    method computeQ (line 247) | computeQ(Y) {
    method sampleInitialSolution (line 275) | sampleInitialSolution() {
    method generateRandom (line 297) | generateRandom(n, mu, std) {
    method calculateL2Distance (line 322) | calculateL2Distance(x1, x2) {
    method calculatePairwiseDistance (line 335) | calculatePairwiseDistance(X) {

FILE: ml/t-sne/src/utils.js
  function clone (line 9) | function clone(src) {
  function writeResult (line 26) | async function writeResult(fileName, result) {

FILE: ml/utils/data_utils.ts
  function splitData (line 1) | function splitData(data: [number[][], number[]], testSize: number = 0.2)...
  function createSample (line 13) | function createSample(d: number, n: number): number[][] {
  function createLabel (line 24) | function createLabel(d: number, c: number, n: number): number[][] {
  function randn (line 39) | function randn(m = 0.0, v = 1.0): number {

FILE: ml/utils/metrics.ts
  class Metrics (line 5) | class Metrics {
    method accuracy (line 6) | static accuracy(label: Matrix, pred: Matrix): number {
    method precision (line 21) | static precision(label: Matrix, pred: Matrix): number {
    method recall (line 43) | static recall(label: Matrix, pred: Matrix): number {
    method f1score (line 66) | static f1score(label: Matrix, pred: Matrix): number {
    method confusionmatrix (line 72) | static confusionmatrix(label: Matrix, pred: Matrix): number[][] {
    method argmax (line 78) | static argmax(arr: number[]): number {

FILE: ml/utils/preprocessing.ts
  class Preprocessing (line 5) | class Preprocessing {
    method scale (line 8) | static scale(data: number[][]): Matrix {
    method binalizeLabel (line 22) | static binalizeLabel(labels: number[]): number[][] {
    method splitData (line 37) | static splitData(data: [number[][], number[]],