greataptic/src/vector.js

A simplistic neural network library.

/* @flow */

function _logit(x: number) {
    return Math.log(x / (1 - x));
}

let Vector = module.exports.Vector = class Vector {
    data: number[];
    dims: number;

    constructor(data: VectorLike) {
        if (data.data != null) data = (data: any).data;

        this.data = Array.from((data: any));
        this.dims = this.data.length;
    }

    co(coord: number) : ?number {
        return this.data[coord] != null ? this.data[coord] : null;
    }

    size() : number {
        return Math.sqrt(this.data.reduce((a, b) => a + Math.pow(b, 2), 0));
    }

    sum() : number {
        return this.data.reduce((a, b) => a + b, 0);
    }

    add(_b: VectorLike) : Vector {
        let b: Vector = _b.dims != null ? (_b: any) : new Vector(_b);

        let res: number[] = [];

        for (let i = 0; i < Math.min(this.dims, b.dims); i++)
            res[i] = this.data[i] + b.data[i];

        return new Vector(res);
    }

    pow(pow: number) : Vector {
        return new Vector(this.data.map((x) => Math.pow(x, pow)));
    }

    sub(_b: VectorLike) : Vector {
        let b: Vector = _b.dims != null ? (_b: any) : new Vector(_b);

        let res: number[] = [];

        for (let i = 0; i < Math.min(this.dims, b.dims); i++)
            res[i] = this.data[i] - b.data[i];

        return new Vector(res);
    }

    multiplyVec(_b: VectorLike) : Vector {
        let b: Vector = _b.dims != null ? (_b: any) : new Vector(_b);

        let res: number[] = [];

        for (let i = 0; i < Math.min(this.dims, b.dims); i++)
            res[i] = this.data[i] * b.data[i];

        return new Vector(res);
    }

    divideVec(_b: VectorLike) : Vector {
        let b: Vector = _b.dims != null ? (_b: any) : new Vector(_b);

        let res: number[] = [];

        for (let i = 0; i < Math.min(this.dims, b.dims); i++)
            res[i] = this.data[i] / b.data[i];

        return new Vector(res);
    }

    multiplyFac(b: number) : Vector {
        return new Vector(this.data.map((a) => a * b));
    }

    divideFac(b: number) : Vector {
        return new Vector(this.data.map((a) => a / b));
    }

    combiner(combinerFunc: (number, number) => number) : (Vector) => Vector {
        return function(b: Vector) {
            if (!b.dims) b = new Vector(b);

            return new Vector(this.data.map((x, i) => combinerFunc(x, b.data[i])));
        };
    }

    map(func: (number) => number) : Vector {
        return new Vector(this.data.map(func));
    }

    dot(b: Vector) : number {
        if (this.data.length === 0 || b.dims === 0)
            return 0;

        let res = 0;

        for (let i = 0; i < Math.min(this.dims, b.dims); i++)
            res += this.data[i] * b.data[i];

        return res;
    }

    static is(vec: Vector | any) {
        return !!(vec && vec.data && vec.dims && vec.size && vec.combiner && vec.map);
    };
    
    static fill(opts: { map: ?((number, number[]) => number), length: number } | { value: ?number, length: number } | { length: number }) : Vector {
        if (opts.map != null)
            return new Vector(new Array(opts.length).fill(0).map((_, i, a) => (opts: any).map(i, a)));
    
        else
            return new Vector(new Array(opts.length).fill((opts: any).value != null ? (opts: any).value : 0));
    };
    
    static random(dims: number) : Vector {
        return new Vector(new Array(dims).fill(0).map(() => _logit(0.25 + 0.5 * Math.random())));
    };
    
    static randomOne() : number {
        return _logit(0.25 + 0.5 * Math.random());
    };
    
    static randomSize(dims: number, size: number) : Vector {
        return new Vector(new Array(dims).fill(0).map(() => (Math.random() * 2 - 1) * size));
    };
    
    static zero(dims: number) : Vector {
        return new Vector(new Array(dims).fill(0));
    };
}

type VectorLike = number[] | Vector;