phasor.js/dist/nodejs/phasor.js

Complex numbers done right

let imports = {};
imports['__wbindgen_placeholder__'] = module.exports;
let wasm;
const { TextDecoder, inspect } = require(String.raw`util`);

let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });

cachedTextDecoder.decode();

let cachegetUint8Memory0 = null;
function getUint8Memory0() {
    if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
        cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
    }
    return cachegetUint8Memory0;
}

function getStringFromWasm0(ptr, len) {
    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
}

function isLikeNone(x) {
    return x === undefined || x === null;
}
/**
* @param {number | undefined} im
* @returns {Phasor}
*/
module.exports.i = function(im) {
    var ret = wasm.i(!isLikeNone(im), isLikeNone(im) ? 0 : im);
    return Phasor.__wrap(ret);
};

/**
* @param {number} mag
* @param {number | undefined} angle
* @returns {Phasor}
*/
module.exports.polar = function(mag, angle) {
    var ret = wasm.polar(mag, !isLikeNone(angle), isLikeNone(angle) ? 0 : angle);
    return Phasor.__wrap(ret);
};

/**
* @param {number} re
* @param {number | undefined} im
* @returns {Phasor}
*/
module.exports.rect = function(re, im) {
    var ret = wasm.rect(re, !isLikeNone(im), isLikeNone(im) ? 0 : im);
    return Phasor.__wrap(ret);
};

function _assertClass(instance, klass) {
    if (!(instance instanceof klass)) {
        throw new Error(`expected instance of ${klass.name}`);
    }
    return instance.ptr;
}
/**
*/
class Phasor {

    static __wrap(ptr) {
        const obj = Object.create(Phasor.prototype);
        obj.ptr = ptr;

        return obj;
    }

    toJSON() {
        return {
            mag: this.mag,
            tan: this.tan,
        };
    }

    toString() {
        return JSON.stringify(this);
    }

    [inspect.custom]() {
        return Object.assign(Object.create({constructor: this.constructor}), this.toJSON());
    }

    free() {
        const ptr = this.ptr;
        this.ptr = 0;

        wasm.__wbg_phasor_free(ptr);
    }
    /**
    * @returns {number}
    */
    get mag() {
        var ret = wasm.__wbg_get_phasor_mag(this.ptr);
        return ret;
    }
    /**
    * @param {number} arg0
    */
    set mag(arg0) {
        wasm.__wbg_set_phasor_mag(this.ptr, arg0);
    }
    /**
    * @returns {number}
    */
    get tan() {
        var ret = wasm.__wbg_get_phasor_tan(this.ptr);
        return ret;
    }
    /**
    * @param {number} arg0
    */
    set tan(arg0) {
        wasm.__wbg_set_phasor_tan(this.ptr, arg0);
    }
    /**
    * @param {number | undefined} mag
    * @param {number | undefined} tan
    */
    constructor(mag, tan) {
        var ret = wasm.phasor_new(!isLikeNone(mag), isLikeNone(mag) ? 0 : mag, !isLikeNone(tan), isLikeNone(tan) ? 0 : tan);
        return Phasor.__wrap(ret);
    }
    /**
    * @returns {number}
    */
    norm() {
        var ret = wasm.phasor_norm(this.ptr);
        return ret;
    }
    /**
    * @returns {number}
    */
    angle() {
        var ret = wasm.phasor_angle(this.ptr);
        return ret;
    }
    /**
    * @returns {number}
    */
    real() {
        var ret = wasm.phasor_real(this.ptr);
        return ret;
    }
    /**
    * @returns {number}
    */
    imag() {
        var ret = wasm.phasor_imag(this.ptr);
        return ret;
    }
    /**
    * @param {Phasor} rhs
    * @returns {Phasor}
    */
    add(rhs) {
        _assertClass(rhs, Phasor);
        var ret = wasm.phasor_add(this.ptr, rhs.ptr);
        return Phasor.__wrap(ret);
    }
    /**
    * @param {Phasor} rhs
    * @returns {Phasor}
    */
    sub(rhs) {
        _assertClass(rhs, Phasor);
        var ret = wasm.phasor_sub(this.ptr, rhs.ptr);
        return Phasor.__wrap(ret);
    }
    /**
    * @param {Phasor} rhs
    * @returns {Phasor}
    */
    mul(rhs) {
        _assertClass(rhs, Phasor);
        var ret = wasm.phasor_mul(this.ptr, rhs.ptr);
        return Phasor.__wrap(ret);
    }
    /**
    * @param {Phasor} rhs
    * @returns {Phasor}
    */
    div(rhs) {
        _assertClass(rhs, Phasor);
        var ret = wasm.phasor_div(this.ptr, rhs.ptr);
        return Phasor.__wrap(ret);
    }
    /**
    * @returns {Phasor}
    */
    neg() {
        var ret = wasm.phasor_neg(this.ptr);
        return Phasor.__wrap(ret);
    }
    /**
    * @returns {Phasor}
    */
    conj() {
        var ret = wasm.phasor_conj(this.ptr);
        return Phasor.__wrap(ret);
    }
    /**
    * @returns {Phasor}
    */
    recip() {
        var ret = wasm.phasor_recip(this.ptr);
        return Phasor.__wrap(ret);
    }
    /**
    * @returns {Phasor}
    */
    ln() {
        var ret = wasm.phasor_ln(this.ptr);
        return Phasor.__wrap(ret);
    }
    /**
    * @param {number} base
    * @returns {Phasor}
    */
    log(base) {
        var ret = wasm.phasor_log(this.ptr, base);
        return Phasor.__wrap(ret);
    }
    /**
    * @returns {Phasor}
    */
    exp() {
        var ret = wasm.phasor_exp(this.ptr);
        return Phasor.__wrap(ret);
    }
    /**
    * @returns {Phasor}
    */
    sinh() {
        var ret = wasm.phasor_sinh(this.ptr);
        return Phasor.__wrap(ret);
    }
    /**
    * @returns {Phasor}
    */
    cosh() {
        var ret = wasm.phasor_cosh(this.ptr);
        return Phasor.__wrap(ret);
    }
    /**
    * @returns {boolean}
    */
    isNaN() {
        var ret = wasm.phasor_isNaN(this.ptr);
        return ret !== 0;
    }
    /**
    * @returns {boolean}
    */
    isInfinite() {
        var ret = wasm.phasor_isInfinite(this.ptr);
        return ret !== 0;
    }
    /**
    * @returns {boolean}
    */
    isFinite() {
        var ret = wasm.phasor_isFinite(this.ptr);
        return ret !== 0;
    }
    /**
    * @returns {boolean}
    */
    isZero() {
        var ret = wasm.phasor_isZero(this.ptr);
        return ret !== 0;
    }
    /**
    * @returns {boolean}
    */
    isSubnormal() {
        var ret = wasm.phasor_isSubnormal(this.ptr);
        return ret !== 0;
    }
    /**
    * @returns {boolean}
    */
    isNormal() {
        var ret = wasm.phasor_isNormal(this.ptr);
        return ret !== 0;
    }
    /**
    * @returns {boolean}
    */
    isReal() {
        var ret = wasm.phasor_isReal(this.ptr);
        return ret !== 0;
    }
    /**
    * @returns {boolean}
    */
    isImaginary() {
        var ret = wasm.phasor_isImaginary(this.ptr);
        return ret !== 0;
    }
    /**
    * @param {Phasor} rhs
    * @param {number | undefined} e
    * @returns {boolean}
    */
    absDiffEq(rhs, e) {
        _assertClass(rhs, Phasor);
        var ret = wasm.phasor_absDiffEq(this.ptr, rhs.ptr, !isLikeNone(e), isLikeNone(e) ? 0 : e);
        return ret !== 0;
    }
    /**
    * @param {Phasor} rhs
    * @param {number | undefined} e
    * @param {number | undefined} rel
    * @returns {boolean}
    */
    relativeEq(rhs, e, rel) {
        _assertClass(rhs, Phasor);
        var ret = wasm.phasor_relativeEq(this.ptr, rhs.ptr, !isLikeNone(e), isLikeNone(e) ? 0 : e, !isLikeNone(rel), isLikeNone(rel) ? 0 : rel);
        return ret !== 0;
    }
    /**
    * @param {Phasor} rhs
    * @param {number | undefined} e
    * @param {number | undefined} ulps
    * @returns {boolean}
    */
    ulpsEq(rhs, e, ulps) {
        _assertClass(rhs, Phasor);
        var ret = wasm.phasor_ulpsEq(this.ptr, rhs.ptr, !isLikeNone(e), isLikeNone(e) ? 0 : e, !isLikeNone(ulps), isLikeNone(ulps) ? 0 : ulps);
        return ret !== 0;
    }
}
module.exports.Phasor = Phasor;

module.exports.__wbindgen_throw = function(arg0, arg1) {
    throw new Error(getStringFromWasm0(arg0, arg1));
};

const path = require('path').join(__dirname, 'phasor_bg.wasm');
const bytes = require('fs').readFileSync(path);

const wasmModule = new WebAssembly.Module(bytes);
const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
wasm = wasmInstance.exports;
module.exports.__wasm = wasm;