kalman-filter.js

var kalmanFilter;
/******/ (() => { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ "./index.js":
/*!******************!*\
  !*** ./index.js ***!
  \******************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {


const modelCollection = __webpack_require__(/*! ./lib/model-collection */ "./lib/model-collection.js");
const defaultDynamicModels = __webpack_require__(/*! ./lib/dynamic */ "./lib/dynamic/index.js");
const defaultObservationModels = __webpack_require__(/*! ./lib/observation */ "./lib/observation/index.js");

Object.keys(defaultDynamicModels).forEach(k => {
	modelCollection.registerDynamic(k, defaultDynamicModels[k]);
});

Object.keys(defaultObservationModels).forEach(k => {
	modelCollection.registerObservation(k, defaultObservationModels[k]);
});

module.exports = Object.assign({
	KalmanFilter: __webpack_require__(/*! ./lib/kalman-filter */ "./lib/kalman-filter.js"),
	getCovariance: __webpack_require__(/*! ./lib/utils/get-covariance */ "./lib/utils/get-covariance.js"),
	State: __webpack_require__(/*! ./lib/state */ "./lib/state.js"),
	checkCovariance: __webpack_require__(/*! ./lib/utils/check-covariance */ "./lib/utils/check-covariance.js"),
	correlationToCovariance: __webpack_require__(/*! ./lib/utils/correlation-to-covariance */ "./lib/utils/correlation-to-covariance.js"),
	covarianceToCorrelation: __webpack_require__(/*! ./lib/utils/covariance-to-correlation */ "./lib/utils/covariance-to-correlation.js"),
	projectObservation: __webpack_require__(/*! ./lib/utils/project-observation */ "./lib/utils/project-observation.js"),
}, modelCollection);


/***/ }),

/***/ "./lib/core-kalman-filter.js":
/*!***********************************!*\
  !*** ./lib/core-kalman-filter.js ***!
  \***********************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {matMul, transpose, add, invert, subtract: sub, identity: getIdentity} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");
const State = __webpack_require__(/*! ./state.js */ "./lib/state.js");
const checkMatrix = __webpack_require__(/*! ./utils/check-matrix.js */ "./lib/utils/check-matrix.js");
/**
* @callback PreviousCorrectedCallback
* @param {Object} opts
* @param {Number} opts.index
* @param {Number} opts.previousCorrected
* @returns {Array.Array.<Number>>}
*/

/**
* @callback PredictedCallback
* @param {Object} opts
* @param {Number} opts.index
* @param {State} opts.predicted
* @param {Observation} opts.observation
* @returns {Array.Array.<Number>>}
*/

/**
* @typedef {Object} ObservationConfig
* @property {Number} dimension
* @property {PredictedCallback} [fn=null] for extended kalman filter only, the non-linear state to observation function
* @property {Array.Array.<Number>> | PreviousCorrectedCallback} stateProjection the matrix to transform state to observation (for EKF, the jacobian of the fn)
* @property {Array.Array.<Number>> | PreviousCorrectedCallback} covariance the covariance of the observation noise
*/

/**
* @typedef {Object} DynamicConfig
* @property {Number} dimension dimension of the state vector
* @property {PreviousCorrectedCallback} [constant=null] a function that returns the control parameter B_k*u_k of the kalman filter
* @property {PreviousCorrectedCallback} [fn=null] for extended kalman filter only, the non-linear state-transition model
* @property {Array.Array.<Number>> | PredictedCallback} transition the state-transition model (or for EKF the jacobian of the fn)
* @property {Array.Array.<Number>> | PredictedCallback} covariance the covariance of the process noise
*/

/**
* @typedef {Object} CoreConfig
* @property {DynamicConfig} dynamic the system's dynamic model
* @property {ObservationConfig} observation the system's observation model
* @property {Object} [logger=defaultLogger] a Winston-like logger
*/
const defaultLogger = {
	info: (...args) => console.log(...args),
	debug() {},
	warn: (...args) => console.log(...args),
	error: (...args) => console.log(...args),
};
/**
 * @param {CoreConfig} options
*/
class CoreKalmanFilter {
	constructor(options) {
		const {dynamic, observation, logger = defaultLogger} = options;
		this.dynamic = dynamic;
		this.observation = observation;
		this.logger = logger;
	}

	getValue(fn, options) {
		return (typeof (fn) === 'function' ? fn(options) : fn);
	}

	getInitState() {
		const {mean: meanInit, covariance: covarianceInit, index: indexInit} = this.dynamic.init;

		const initState = new State({
			mean: meanInit,
			covariance: covarianceInit,
			index: indexInit,
		});
		State.check(initState, {title: 'dynamic.init'});
		return initState;
	}

	/**
	This will return the predicted covariance of a given previousCorrected State, this will help us to build the asymptoticState.
	* @param {State} previousCorrected
	* @returns{Array.<Array.<Number>>}
	*/

	getPredictedCovariance(options = {}) {
		let {previousCorrected, index} = options;
		previousCorrected = previousCorrected || this.getInitState();

		const getValueOptions = Object.assign({}, {previousCorrected, index}, options);
		const transition = this.getValue(this.dynamic.transition, getValueOptions);

		checkMatrix(transition, [this.dynamic.dimension, this.dynamic.dimension], 'dynamic.transition');

		const transitionTransposed = transpose(transition);
		const covarianceInter = matMul(transition, previousCorrected.covariance);
		const covariancePrevious = matMul(covarianceInter, transitionTransposed);
		const dynCov = this.getValue(this.dynamic.covariance, getValueOptions);

		const covariance = add(
			dynCov,
			covariancePrevious,
		);
		checkMatrix(covariance, [this.dynamic.dimension, this.dynamic.dimension], 'predicted.covariance');

		return covariance;
	}

	predictMean(o) {
		const mean = this.predictMeanWithoutControl(o);
		if (!this.dynamic.constant) {
			return mean;
		}

		const {opts} = o;
		const control = this.dynamic.constant(opts);
		checkMatrix(control, [this.dynamic.dimension, 1], 'dynamic.constant');
		return add(mean, control);
	}

	predictMeanWithoutControl({opts, transition}) {
		if (this.dynamic.fn) {
			return this.dynamic.fn(opts);
		}

		const {previousCorrected} = opts;
		return matMul(transition, previousCorrected.mean);
	}
	/**
	This will return the new prediction, relatively to the dynamic model chosen
	* @param {State} previousCorrected State relative to our dynamic model
	* @returns{State} predicted State
	*/

	predict(options = {}) {
		let {previousCorrected, index} = options;
		previousCorrected = previousCorrected || this.getInitState();

		if (typeof (index) !== 'number' && typeof (previousCorrected.index) === 'number') {
			index = previousCorrected.index + 1;
		}

		State.check(previousCorrected, {dimension: this.dynamic.dimension});
		const getValueOptions = Object.assign({}, options, {
			previousCorrected,
			index,
		});

		const transition = this.getValue(this.dynamic.transition, getValueOptions);

		const mean = this.predictMean({transition, opts: getValueOptions});

		const covariance = this.getPredictedCovariance(getValueOptions);

		const predicted = new State({mean, covariance, index});
		this.logger.debug('Prediction done', predicted);
		if (Number.isNaN(predicted.mean[0][0])) {
			throw (new TypeError('nan'));
		}

		return predicted;
	}
	/**
	This will return the new correction, taking into account the prediction made
	and the observation of the sensor
	* @param {State} predicted the previous State
	* @returns{Array<Array>} kalmanGain
	*/

	getGain(options) {
		let {predicted, stateProjection} = options;
		const getValueOptions = Object.assign({}, {index: predicted.index}, options);
		stateProjection = stateProjection || this.getValue(this.observation.stateProjection, getValueOptions);
		const obsCovariance = this.getValue(this.observation.covariance, getValueOptions);
		checkMatrix(obsCovariance, [this.observation.dimension, this.observation.dimension], 'observation.covariance');
		const stateProjTransposed = transpose(stateProjection);

		checkMatrix(stateProjection, [this.observation.dimension, this.dynamic.dimension], 'observation.stateProjection');

		const noiselessInnovation = matMul(
			matMul(stateProjection, predicted.covariance),
			stateProjTransposed,
		);

		const innovationCovariance = add(noiselessInnovation, obsCovariance);

		const optimalKalmanGain = matMul(
			matMul(predicted.covariance, stateProjTransposed),
			invert(innovationCovariance),
		);

		return optimalKalmanGain;
	}

	/**
	This will return the corrected covariance of a given predicted State, this will help us to build the asymptoticState.
	* @param {State} predicted the previous State
	* @returns{Array.<Array.<Number>>}
	*/

	getCorrectedCovariance(options) {
		let {predicted, optimalKalmanGain, stateProjection} = options;
		const identity = getIdentity(predicted.covariance.length);
		if (!stateProjection) {
			const getValueOptions = Object.assign({}, {index: predicted.index}, options);
			stateProjection = this.getValue(this.observation.stateProjection, getValueOptions);
		}

		if (!optimalKalmanGain) {
			optimalKalmanGain = this.getGain(Object.assign({stateProjection}, options));
		}

		return matMul(
			sub(identity, matMul(optimalKalmanGain, stateProjection)),
			predicted.covariance,
		);
	}

	getPredictedObservation({opts, stateProjection}) {
		if (this.observation.fn) {
			return this.observation.fn(opts);
		}

		const {predicted} = opts;
		return matMul(stateProjection, predicted.mean);
	}

	/**
	This will return the new correction, taking into account the prediction made
	and the observation of the sensor
	* @param {State} predicted the previous State
	* @param {Array} observation the observation of the sensor
	* @returns{State} corrected State of the Kalman Filter
	*/

	correct(options) {
		const {predicted, observation} = options;
		State.check(predicted, {dimension: this.dynamic.dimension});
		if (!observation) {
			throw (new Error('no measure available'));
		}

		const getValueOptions = Object.assign({}, {observation, predicted, index: predicted.index}, options);
		const stateProjection = this.getValue(this.observation.stateProjection, getValueOptions);

		const optimalKalmanGain = this.getGain(Object.assign({predicted, stateProjection}, options));

		const innovation = sub(
			observation,
			this.getPredictedObservation({stateProjection, opts: getValueOptions}),
		);

		const mean = add(
			predicted.mean,
			matMul(optimalKalmanGain, innovation),
		);
		if (Number.isNaN(mean[0][0])) {
			console.log({optimalKalmanGain, innovation, predicted});
			throw (new TypeError('Mean is NaN after correction'));
		}

		const covariance = this.getCorrectedCovariance(Object.assign({predicted, optimalKalmanGain, stateProjection}, options));
		const corrected = new State({mean, covariance, index: predicted.index});
		this.logger.debug('Correction done', corrected);
		return corrected;
	}
}

module.exports = CoreKalmanFilter;


/***/ }),

/***/ "./lib/dynamic/composition.js":
/*!************************************!*\
  !*** ./lib/dynamic/composition.js ***!
  \************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {buildDynamic} = __webpack_require__(/*! ../model-collection */ "./lib/model-collection.js");

/**
* @typedef {Object.<DynamicName, DynamicConfig>} PerNameConfigs
*/
/**
* @typedef {Object} DynamicConfig
* @param {Array.<Number>} obsIndexes
* @param {Covariance} staticCovariance
*/

/**
*Creates a dynamic model, considering the null in order to make the predictions
* @param {Object} main
* @param {Object.<String, DynamicConfig>} main.perName
* @param {ObservationConfig} observation
* @param {Array.<Array.<Number>>} opts.observedProjection
* @returns {DynamicConfig}
*/
module.exports = function ({perName}, observation) {
	const {observedProjection} = observation;
	const observedDynamDimension = observedProjection[0].length;

	const dynamicNames = Object.keys(perName);

	const confs = {};
	let nextDynamicDimension = observedDynamDimension;
	let nextObservedDimension = 0;
	dynamicNames.forEach(k => {
		const obsDynaIndexes = perName[k].obsDynaIndexes;
		if (typeof (perName[k].name) === 'string' && perName[k].name !== k) {
			throw (new Error(`${perName[k].name} and "${k}" should match`));
		}

		perName[k].name = k;

		const {dimension, transition, covariance, init} = buildDynamic(perName[k], observation);

		const dynamicIndexes = [];
		for (let i = 0; i < dimension; i++) {
			const isObserved = (i < obsDynaIndexes.length);
			let newIndex;
			if (isObserved) {
				newIndex = nextObservedDimension;
				if (newIndex !== obsDynaIndexes[i]) {
					throw (new Error('thsoe should match'));
				}

				nextObservedDimension++;
			} else {
				newIndex = nextDynamicDimension;
				nextDynamicDimension++;
			}

			dynamicIndexes.push(newIndex);
		}

		confs[k] = {
			dynamicIndexes,
			transition,
			dimension,
			covariance,
			init,
		};
	});

	const totalDimension = dynamicNames.map(k => confs[k].dimension).reduce((a, b) => a + b, 0);

	if (nextDynamicDimension !== totalDimension) {
		throw (new Error('miscalculation of transition'));
	}

	const init = {
		index: -1,
		mean: new Array(totalDimension),
		covariance: new Array(totalDimension).fill(0).map(() => new Array(totalDimension).fill(0)),
	};
	dynamicNames.forEach(k => {
		const {
			dynamicIndexes,
			init: localInit,
		} = confs[k];
		if (typeof (localInit) !== 'object') {
			throw new TypeError('Init is mandatory');
		}

		dynamicIndexes.forEach((c1, i1) => dynamicIndexes.forEach((c2, i2) => {
			init.covariance[c1][c2] = localInit.covariance[i1][i2];
		}));
		dynamicIndexes.forEach((c1, i1) => {
			init.mean[c1] = localInit.mean[i1];
		});
	});
	return {
		dimension: totalDimension,
		init,
		transition(options) {
			const {previousCorrected} = options;
			const resultTransition = new Array(totalDimension).fill().map(() => new Array(totalDimension).fill(0));

			dynamicNames.forEach(k => {
				const {
					dynamicIndexes,
					transition,
				} = confs[k];

				const options2 = Object.assign({}, options, {previousCorrected: previousCorrected.subState(dynamicIndexes)});
				const trans = transition(options2);
				dynamicIndexes.forEach((c1, i1) => dynamicIndexes.forEach((c2, i2) => {
					resultTransition[c1][c2] = trans[i1][i2];
				}));
			});
			return resultTransition;
		},
		covariance(options) {
			const {previousCorrected} = options;
			const resultCovariance = new Array(totalDimension).fill().map(() => new Array(totalDimension).fill(0));

			dynamicNames.forEach(k => {
				const {
					dynamicIndexes,
					covariance,
				} = confs[k];

				const options2 = Object.assign({}, options, {previousCorrected: previousCorrected.subState(dynamicIndexes)});

				const cov = covariance(options2);
				// Console.log('dynamic.composition',k, cov, dynamicIndexes)
				dynamicIndexes.forEach((c1, i1) => dynamicIndexes.forEach((c2, i2) => {
					resultCovariance[c1][c2] = cov[i1][i2];
				}));
			});
			return resultCovariance;
		},
	};
};


/***/ }),

/***/ "./lib/dynamic/constant-acceleration.js":
/*!**********************************************!*\
  !*** ./lib/dynamic/constant-acceleration.js ***!
  \**********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {identity} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");

/**
*Creates a dynamic model, following constant acceleration model with respect with the dimensions provided in the observation parameters
* @param {DynamicConfig} dynamic
* @param {ObservationConfig} observation
* @returns {DynamicConfig}
*/

module.exports = function (dynamic, observation) {
	const timeStep = dynamic.timeStep || 1;
	const {observedProjection} = observation;
	const {stateProjection} = observation;
	const observationDimension = observation.dimension;
	let dimension;

	if (stateProjection && Number.isInteger(stateProjection[0].length / 3)) {
		dimension = observation.stateProjection[0].length;
	} else if (observedProjection) {
		dimension = observedProjection[0].length * 3;
	} else if (observationDimension) {
		dimension = observationDimension * 3;
	} else {
		throw (new Error('observedProjection or stateProjection should be defined in observation in order to use constant-speed filter'));
	}

	const baseDimension = dimension / 3;
	// We construct the transition and covariance matrices
	const transition = identity(dimension);
	for (let i = 0; i < baseDimension; i++) {
		transition[i][i + baseDimension] = timeStep;
		transition[i][i + (2 * baseDimension)] = 0.5 * (timeStep ** 2);
		transition[i + baseDimension][i + (2 * baseDimension)] = timeStep;
	}

	const arrayCovariance = new Array(baseDimension).fill(1)
		.concat(new Array(baseDimension).fill(timeStep * timeStep))
		.concat(new Array(baseDimension).fill(timeStep ** 4));
	const covariance = dynamic.covariance || arrayCovariance;
	return Object.assign({}, dynamic, {dimension, transition, covariance});
};


/***/ }),

/***/ "./lib/dynamic/constant-position-with-null.js":
/*!****************************************************!*\
  !*** ./lib/dynamic/constant-position-with-null.js ***!
  \****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {identity, diag} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");

const huge = 1e6;

/**
*Creates a dynamic model, considering the null in order to make the predictions
* @param {Array.<Array.<Number>>} staticCovariance generated with moving average
* @param {Number} observationDimension
* @returns {DynamicConfig}
*/
const constantPositionWithNull = function ({staticCovariance, obsDynaIndexes, init}) {
	const dimension = obsDynaIndexes.length;
	if (!init) {
		init = {
			mean: new Array(obsDynaIndexes.length).fill(0).map(() => [0]),
			covariance: diag(new Array(obsDynaIndexes.length).fill(huge)),
			index: -1,
		};
	}

	if (staticCovariance && staticCovariance.length !== dimension) {
		throw (new Error('staticCovariance has wrong size'));
	}

	return {
		dimension,
		transition() {
			return identity(dimension);
		},
		covariance({previousCorrected, index}) {
			const diffBetweenIndexes = index - previousCorrected.index;
			if (staticCovariance) {
				return staticCovariance.map(row => row.map(element => element * diffBetweenIndexes));
			}

			return identity(dimension);
		},
		init,
	};
};

module.exports = constantPositionWithNull;


/***/ }),

/***/ "./lib/dynamic/constant-position.js":
/*!******************************************!*\
  !*** ./lib/dynamic/constant-position.js ***!
  \******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {identity} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");
/**
*Creates a dynamic model, following constant position model with respect with the dimensions provided in the observation parameters
* @param {DynamicConfig} dynamic
* @param {ObservationConfig} observation
* @returns {DynamicConfig}
*/

module.exports = function (dynamic, observation) {
	let {dimension} = dynamic;
	const observationDimension = observation.dimension;
	const {observedProjection} = observation;
	const {stateProjection} = observation;
	let {covariance} = dynamic;

	if (!dynamic.dimension) {
		if (observationDimension) {
			dimension = observationDimension;
		} else if (observedProjection) {
			dimension = observedProjection[0].length;
		} else if (stateProjection) {
			dimension = stateProjection[0].length;
		}
	}

	const transition = identity(dimension);
	covariance = covariance || identity(dimension);
	return Object.assign({}, dynamic, {dimension, transition, covariance});
};


/***/ }),

/***/ "./lib/dynamic/constant-speed-dynamic.js":
/*!***********************************************!*\
  !*** ./lib/dynamic/constant-speed-dynamic.js ***!
  \***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {diag} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");

/**
*Creates a dynamic model, considering the null in order to make the predictions
* @param {Array.<Number>} staticCovariance
* @param {ObservationConfig} observation
* @returns {DynamicConfig}
*/
const constantSpeedDynamic = function ({staticCovariance, avSpeed, center}, observation) {
	const observationDimension = observation.observedProjection[0].length;

	const dimension = 2 * observationDimension;

	if ((center) === undefined) {
		throw (new TypeError('Center must be defined'));
	}

	if (center.length !== observationDimension) {
		throw (new TypeError(`Center size should be ${observationDimension}`));
	}

	if (avSpeed.length !== observationDimension) {
		throw (new TypeError(`avSpeed size should be ${observationDimension}`));
	}

	const initCov = diag(center.map(c => c * c / 3).concat(avSpeed.map(c => c * c / 3)));

	const init = {
		mean: center.map(c => [c]).concat(center.map(() => [0])),
		covariance: initCov,
		index: -1,
	};

	const transition = ({getTime, index, previousCorrected}) => {
		const dT = getTime(index) - getTime(previousCorrected.index);
		if (typeof (dT) !== 'number' || Number.isNaN(dT)) {
			throw (new TypeError(`dT (${dT}) should be a number`));
		}
		// Example is :
		// [
		// 	[1, 0, dT, 0],
		// 	[0, 1, 0, dT],
		// 	[0, 0, 1, 0],
		// 	[0, 0, 0, 1]
		// ];
		// constant speed usual matrix

		// create identity matrix
		const mat = diag(center.map(() => 1).concat(center.map(() => 1)));
		// Then add dT
		for (let i = 0; i < observationDimension; i++) {
			mat[i][observationDimension + i] = dT;
		}

		if (Number.isNaN(mat[0][2])) {
			throw (new TypeError('nan mat'));
		}

		return mat;
	};

	const covariance = ({index, previousCorrected, getTime}) => {
		const dT = getTime(index) - getTime(previousCorrected.index);

		if (typeof (dT) !== 'number') {
			throw (new TypeError(`dT (${dT}) should be a number`));
		}

		// State is (x, y, vx, vy)
		const sqrt = Math.sqrt(dT);
		if (Number.isNaN(sqrt)) {
			console.log({lastPreviousIndex: previousCorrected.index, index});
			console.log(dT, previousCorrected.index, index, getTime(index), getTime(previousCorrected.index));
			throw (new Error('Sqrt(dT) is NaN'));
		}

		return diag(staticCovariance.map(v => v * sqrt));
	};

	return {
		init,
		dimension,
		transition,
		covariance,
	};
};

module.exports = constantSpeedDynamic;


/***/ }),

/***/ "./lib/dynamic/constant-speed-with-null.js":
/*!*************************************************!*\
  !*** ./lib/dynamic/constant-speed-with-null.js ***!
  \*************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {identity, diag} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");

const nullModels = {
	linear(a) {
		return a;
	},
	one() {
		return 1;
	},
	square(a) {
		return a * a;
	},
};
const huge = 1e6;
/**
*Creates a dynamic model, considering the null in order to make the predictions
* @param {Array.<Array.<Number>>} staticCovariance generated with moving average
* @param {ObservationConfig} observation
* @returns {DynamicConfig}
*/
const constantSpeedWithNull = function ({staticCovariance, obsDynaIndexes, nullGapModel = null, init}, observation) {
	if (!obsDynaIndexes) {
		const l = observation.observedProjection[0].length;
		obsDynaIndexes = new Array(l).fill(0).map((_, i) => i);
	}

	if (staticCovariance && Number.isNaN(staticCovariance[0][0])) {
		throw (new Error('NaN staticCovariance'));
	}

	const dimension = 2 * obsDynaIndexes.length;
	if (!init) {
		init = {
			mean: new Array(obsDynaIndexes.length * 2).fill(0).map(() => [0]),
			covariance: diag(new Array(obsDynaIndexes.length * 2).fill(huge)),
			index: -1,
		};
	}

	if (!nullGapModel) {
		nullGapModel = new Array(dimension).fill(0).map(() => 'linear');
	}

	return {
		dimension,
		init,
		transition({previousCorrected, index}) {
			const diffBetweenIndexes = index - previousCorrected.index;

			if (Number.isNaN(diffBetweenIndexes)) {
				throw (new TypeError('diffBetweenIndexes is NaN'));
			}

			const emptyTransition = new Array(dimension).fill(new Array(dimension).fill());

			const observationDimension = dimension / 2;
			const transition = emptyTransition.map((row, rowId) => row.map((col, colId) => {
				if (rowId === colId) {
					return 1;
				}

				if (rowId + observationDimension === colId) {
					if (index === 0) {
						return 0;
					}

					return diffBetweenIndexes;
				}

				return 0;
			}));
			return transition;
		},
		covariance({previousCorrected, index}) {
			const diffBetweenIndexes = index - previousCorrected.index;
			if (staticCovariance) {
				const covariance = staticCovariance.map((row, rowIndex) => row.map((element, colIndex) => {
					const factor = Math.sqrt(nullModels[nullGapModel[rowIndex]](diffBetweenIndexes) * nullModels[nullGapModel[colIndex]](diffBetweenIndexes));
					return element * factor;
				}));

				return covariance;
			}

			return identity(dimension);
		},
	};
};

module.exports = constantSpeedWithNull;


/***/ }),

/***/ "./lib/dynamic/constant-speed.js":
/*!***************************************!*\
  !*** ./lib/dynamic/constant-speed.js ***!
  \***************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {identity} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");

/**
*Creates a dynamic model, following constant position model with respect with the dimensions provided in the observation parameters
* @param {DynamicConfig} dynamic
* @param {ObservationConfig} observation
* @returns {DynamicConfig}
*/

module.exports = function (dynamic, observation) {
	const timeStep = dynamic.timeStep || 1;
	const {observedProjection} = observation;
	const {stateProjection} = observation;
	const observationDimension = observation.dimension;
	let dimension;

	if (stateProjection && Number.isInteger(stateProjection[0].length / 2)) {
		dimension = observation.stateProjection[0].length;
	} else if (observedProjection) {
		dimension = observedProjection[0].length * 2;
	} else if (observationDimension) {
		dimension = observationDimension * 2;
	} else {
		throw (new Error('observedProjection or stateProjection should be defined in observation in order to use constant-speed filter'));
	}

	const baseDimension = dimension / 2;
	// We construct the transition and covariance matrices
	const transition = identity(dimension);
	for (let i = 0; i < baseDimension; i++) {
		transition[i][i + baseDimension] = timeStep;
	}

	const arrayCovariance = new Array(baseDimension).fill(1).concat(new Array(baseDimension).fill(timeStep * timeStep));
	const covariance = dynamic.covariance || arrayCovariance;
	return Object.assign({}, dynamic, {dimension, transition, covariance});
};


/***/ }),

/***/ "./lib/dynamic/index.js":
/*!******************************!*\
  !*** ./lib/dynamic/index.js ***!
  \******************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

module.exports = {
	'constant-position': __webpack_require__(/*! ./constant-position.js */ "./lib/dynamic/constant-position.js"),
	'constant-speed': __webpack_require__(/*! ./constant-speed.js */ "./lib/dynamic/constant-speed.js"),
	'constant-acceleration': __webpack_require__(/*! ./constant-acceleration.js */ "./lib/dynamic/constant-acceleration.js"),
	composition: __webpack_require__(/*! ./composition.js */ "./lib/dynamic/composition.js"),
	'constant-position-with-null': __webpack_require__(/*! ./constant-position-with-null.js */ "./lib/dynamic/constant-position-with-null.js"),
	'constant-speed-with-null': __webpack_require__(/*! ./constant-speed-with-null.js */ "./lib/dynamic/constant-speed-with-null.js"),
	'constant-speed-dynamic': __webpack_require__(/*! ./constant-speed-dynamic.js */ "./lib/dynamic/constant-speed-dynamic.js"),
	'shortterm-constant-speed': __webpack_require__(/*! ./shortterm-constant-speed.js */ "./lib/dynamic/shortterm-constant-speed.js"),
};


/***/ }),

/***/ "./lib/dynamic/shortterm-constant-speed.js":
/*!*************************************************!*\
  !*** ./lib/dynamic/shortterm-constant-speed.js ***!
  \*************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {elemWise, diag} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");
const constantSpeedDynamic = __webpack_require__(/*! ./constant-speed-dynamic */ "./lib/dynamic/constant-speed-dynamic.js");

const safeDiv = function (a, b) {
	if (a === 0) {
		return 0;
	}

	if (b === 0) {
		return 1;
	}

	return a / b;
};

/**
* This model is based on the constant speed model
* The constant speed model creates problems when dT >> fps (the track is lost)
* then the expected position can be very far from the center of the field
* to solve that, we use a model with 2 more hidden variable that are always center of the field
* When dT << typicalTime the model acts exactly as a constant speed model
* When dT >> typicalTime the model is a constant [x,y] = center model, sigma = defaultVariance
* @param {Object} options
* @param {ObservationConfig} observation
* @param {Number} [options.typicalTime=10]
* @returns {DynamicConfig}
*/
module.exports = function (options, observation) {
	const {typicalTimes} = options;

	if (!Array.isArray(typicalTimes)) {
		throw (new TypeError('typicalTimes must be defined'));
	}

	const constantSpeed = constantSpeedDynamic(options, observation);
	const {dimension, init} = constantSpeed;

	if (typicalTimes.length !== dimension) {
		throw (new TypeError(`typicalTimes (${typicalTimes.length}) length is not as expected (${dimension})`));
	}

	const mixMatrix = function ({
		ratios,
		aMat,
		bMat,
	}) {
		return elemWise([aMat, bMat], ([m, d], rowIndex, colIndex) => {
			const ratio = rowIndex === colIndex ? ratios[rowIndex] : (ratios[rowIndex] + ratios[colIndex]) / 2;

			return (ratio * m) + ((1 - ratio) * d);
		});
	};

	return {
		dimension,
		init,
		transition(options) {
			const aMat = constantSpeed.transition(options);

			const {getTime, index, previousCorrected} = options;
			const dT = getTime(index) - getTime(previousCorrected.index);

			const ratios = typicalTimes.map(t => Math.exp(-1 * dT / t));

			// 'back to init' matrix
			const bMat = diag(
				elemWise([init.mean, previousCorrected.mean], ([m, d]) => safeDiv(m, d))
				// Flatten cause this is a Nx1 matrix -> N array
					.reduce((a, b) => a.concat(b)),
			);

			return mixMatrix({ratios, aMat, bMat});
		},
		covariance(options, observation) {
			const {getTime, index, previousCorrected} = options;

			const dT = getTime(index) - getTime(previousCorrected.index);
			// State is (x, y, vx, vy)
			const ratios = typicalTimes.map(t => Math.exp(-1 * dT / t));
			const aMat = constantSpeed.covariance(options, observation);
			return mixMatrix({ratios, aMat, bMat: init.covariance});
		},
	};
};


/***/ }),

/***/ "./lib/kalman-filter.js":
/*!******************************!*\
  !*** ./lib/kalman-filter.js ***!
  \******************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {


const {frobenius: distanceMat} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");
const arrayToMatrix = __webpack_require__(/*! ../lib/utils/array-to-matrix.js */ "./lib/utils/array-to-matrix.js");
const setDimensions = __webpack_require__(/*! ../lib/setup/set-dimensions.js */ "./lib/setup/set-dimensions.js");
const checkDimensions = __webpack_require__(/*! ../lib/setup/check-dimensions.js */ "./lib/setup/check-dimensions.js");
const buildStateProjection = __webpack_require__(/*! ../lib/setup/build-state-projection.js */ "./lib/setup/build-state-projection.js");
const extendDynamicInit = __webpack_require__(/*! ../lib/setup/extend-dynamic-init.js */ "./lib/setup/extend-dynamic-init.js");
const toFunction = __webpack_require__(/*! ../lib/utils/to-function.js */ "./lib/utils/to-function.js");
const deepAssign = __webpack_require__(/*! ../lib/utils/deep-assign.js */ "./lib/utils/deep-assign.js");
const polymorphMatrix = __webpack_require__(/*! ../lib/utils/polymorph-matrix.js */ "./lib/utils/polymorph-matrix.js");
const State = __webpack_require__(/*! ./state.js */ "./lib/state.js");
const modelCollection = __webpack_require__(/*! ./model-collection.js */ "./lib/model-collection.js");
const CoreKalmanFilter = __webpack_require__(/*! ./core-kalman-filter.js */ "./lib/core-kalman-filter.js");

/**
 * @typedef {String} DynamicNonObjectConfig
 */
/**
 * @typedef {DynamicConfig} DynamicObjectConfig
 * @property {String} name
 */
/**
 * @param {DynamicNonObjectConfig} dynamic
 * @returns {DynamicObjectConfig}
 */

const buildDefaultDynamic = function (dynamic) {
	if (typeof (dynamic) === 'string') {
		return {name: dynamic};
	}

	return {name: 'constant-position'};
};

/**
 * @typedef {String | Number} ObservationNonObjectConfig
 */
/**
 * @typedef {ObservationConfig} ObservationObjectConfig
 * @property {String} name
 */
/**
 * @param {ObservationNonObjectConfig} observation
 * @returns {ObservationObjectConfig}
 */
const buildDefaultObservation = function (observation) {
	if (typeof (observation) === 'number') {
		return {name: 'sensor', sensorDimension: observation};
	}

	if (typeof (observation) === 'string') {
		return {name: observation};
	}

	return {name: 'sensor'};
};
/**
*This function fills the given options by successively checking if it uses a registered model,
* it builds and checks the dynamic and observation dimensions, build the stateProjection if only observedProjection
*is given, and initialize dynamic.init
*@param {DynamicObjectConfig | DynamicNonObjectConfig} options.dynamic
*@param {ObservationObjectConfig | ObservationNonObjectConfig} options.observation
* @returns {CoreConfig}
*/

const setupModelsParameters = function ({observation, dynamic}) {
	if (typeof (observation) !== 'object' || observation === null) {
		observation = buildDefaultObservation(observation);
	}

	if (typeof (dynamic) !== 'object' || dynamic === null) {
		dynamic = buildDefaultDynamic(dynamic, observation);
	}

	if (typeof (observation.name) === 'string') {
		observation = modelCollection.buildObservation(observation);
	}

	if (typeof (dynamic.name) === 'string') {
		dynamic = modelCollection.buildDynamic(dynamic, observation);
	}

	const withDimensionOptions = setDimensions({observation, dynamic});
	const checkedDimensionOptions = checkDimensions(withDimensionOptions);
	const buildStateProjectionOptions = buildStateProjection(checkedDimensionOptions);
	return extendDynamicInit(buildStateProjectionOptions);
};

/**
* @typedef {Object} ModelsParameters
* @property {DynamicObjectConfig} dynamic
* @property {ObservationObjectConfig} observation
*/

/**
* Returns the corresponding model without arrays as values but only functions
* @param {ModelsParameters} modelToBeChanged
* @returns {CoreConfig} model with respect of the Core Kalman Filter properties
*/
const modelsParametersToCoreOptions = function (modelToBeChanged) {
	const {observation, dynamic} = modelToBeChanged;
	return deepAssign(modelToBeChanged, {
		observation: {
			stateProjection: toFunction(polymorphMatrix(observation.stateProjection), {label: 'observation.stateProjection'}),
			covariance: toFunction(polymorphMatrix(observation.covariance, {dimension: observation.dimension}), {label: 'observation.covariance'}),
		},
		dynamic: {
			transition: toFunction(polymorphMatrix(dynamic.transition), {label: 'dynamic.transition'}),
			covariance: toFunction(polymorphMatrix(dynamic.covariance, {dimension: dynamic.dimension}), {label: 'dynamic.covariance'}),
		},
	});
};

class KalmanFilter extends CoreKalmanFilter {
	/**
	* @typedef {Object} Config
	* @property {DynamicObjectConfig | DynamicNonObjectConfig} dynamic
	* @property {ObservationObjectConfig | ObservationNonObjectConfig} observation
	*/
	/**
	* @param {Config} options
	*/
	constructor(options = {}) {
		const modelsParameters = setupModelsParameters(options);
		const coreOptions = modelsParametersToCoreOptions(modelsParameters);

		super(Object.assign({}, options, coreOptions));
	}

	correct(options) {
		const coreObservation = arrayToMatrix({observation: options.observation, dimension: this.observation.dimension});
		return super.correct(Object.assign({}, options, {observation: coreObservation}));
	}

	/**
	*Performs the prediction and the correction steps
	*@param {State} previousCorrected
	*@param {<Array.<Number>>} observation
	*@returns {Array.<Number>} the mean of the corrections
	*/

	filter(options) {
		const predicted = super.predict(options);
		return this.correct(Object.assign({}, options, {predicted}));
	}

	/**
*Filters all the observations
*@param {Array.<Array.<Number>>} observations
*@returns {Array.<Array.<Number>>} the mean of the corrections
*/
	filterAll(observations) {
		let previousCorrected = this.getInitState();
		const results = [];
		for (const observation of observations) {
			const predicted = this.predict({previousCorrected});
			previousCorrected = this.correct({
				predicted,
				observation,
			});
			results.push(previousCorrected.mean.map(m => m[0]));
		}

		return results;
	}

	/**
	* Returns an estimation of the asymptotic state covariance as explained in https://en.wikipedia.org/wiki/Kalman_filter#Asymptotic_form
	* in practice this can be used as a init.covariance value but is very costful calculation (that's why this is not made by default)
	* @param {Number} [limitIterations=1e2] max number of iterations
	* @param {Number} [tolerance=1e-6] returns when the last values differences are less than tolerance
	* @return {Array.<Array.<Number>>} covariance
	*/
	asymptoticStateCovariance({limitIterations = 1e2, tolerance = 1e-6} = {}) {
		let previousCorrected = super.getInitState();
		let predicted;
		const results = [];
		for (let i = 0; i < limitIterations; i++) {
			// We create a fake mean that will not be used in order to keep coherence
			predicted = new State({
				mean: null,
				covariance: super.getPredictedCovariance({previousCorrected}),
			});
			previousCorrected = new State({
				mean: null,
				covariance: super.getCorrectedCovariance({predicted}),
			});
			results.push(previousCorrected.covariance);
			if (distanceMat(previousCorrected.covariance, results[i - 1]) < tolerance) {
				return results[i];
			}
		}

		throw (new Error('The state covariance does not converge asymptotically'));
	}

	/**
	* Returns an estimation of the asymptotic gain, as explained in https://en.wikipedia.org/wiki/Kalman_filter#Asymptotic_form
	* @param {Number} [tolerance=1e-6] returns when the last values differences are less than tolerance
	* @return {Array.<Array.<Number>>} gain
	*/
	asymptoticGain({tolerance = 1e-6} = {}) {
		const covariance = this.asymptoticStateCovariance({tolerance});

		const asymptoticState = new State({
			// We create a fake mean that will not be used in order to keep coherence
			mean: Array.from({length: covariance.length}).fill(0).map(() => [0]),
			covariance,
		});

		return super.getGain({predicted: asymptoticState});
	}
}

module.exports = KalmanFilter;


/***/ }),

/***/ "./lib/model-collection.js":
/*!*********************************!*\
  !*** ./lib/model-collection.js ***!
  \*********************************/
/***/ ((module) => {


const registeredObservationModels = {};
const registeredDynamicModels = {};

module.exports = {
	/**
	* Enables to register observation model and store it
	* @param {String} name
	* @callback fn the function corresponding to the desired model
	*/

	registerObservation(name, fn) {
		registeredObservationModels[name] = fn;
	},
	/**
	* Enables to register dynamic model and store it
	* @param {String} name
	* @callback fn the function corresponding to the desired model
	*/

	registerDynamic(name, fn) {
		registeredDynamicModels[name] = fn;
	},
	/**
	* Build a model given an observation configuration
	* @param {ObservationConfig} observation
	* @returns {ObservationConfig} the configuration with respect to the model
	*/
	buildObservation(observation) {
		if (typeof (registeredObservationModels[observation.name]) !== 'function') {
			throw (new TypeError(`The provided observation model name (${observation.name}) is not registered`));
		}

		return registeredObservationModels[observation.name](observation);
	},
	/**
	* Build a model given dynamic and observation configurations
	* @param {DynamicConfig} dynamic
	* @param {ObservationConfig} observation
	* @returns {DynamicConfig} the dynamic configuration with respect to the model
	*/

	buildDynamic(dynamic, observation) {
		if (typeof (registeredDynamicModels[dynamic.name]) !== 'function') {
			throw (new TypeError(`The provided dynamic model (${dynamic.name}) name is not registered`));
		}

		return registeredDynamicModels[dynamic.name](dynamic, observation);
	},
};


/***/ }),

/***/ "./lib/observation/index.js":
/*!**********************************!*\
  !*** ./lib/observation/index.js ***!
  \**********************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

module.exports = {
	sensor: __webpack_require__(/*! ./sensor.js */ "./lib/observation/sensor.js"),
	'sensor-local-variance': __webpack_require__(/*! ./sensor-local-variance */ "./lib/observation/sensor-local-variance.js"),
	'sensor-projected': __webpack_require__(/*! ./sensor-projected */ "./lib/observation/sensor-projected.js"),
};


/***/ }),

/***/ "./lib/observation/sensor-local-variance.js":
/*!**************************************************!*\
  !*** ./lib/observation/sensor-local-variance.js ***!
  \**************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {identity} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");
const {buildObservation} = __webpack_require__(/*! ../model-collection */ "./lib/model-collection.js");
/**
* @param {Object} options
* @param {Number} options.sensorDimension
* @param {CovarianceParam} options.sensorCovariance
* @param {Number} options.nSensors
* @returns {ObservationConfig}
*/

const nullableSensor = function (options) {
	const {dimension, observedProjection, covariance: baseCovariance} = buildObservation(Object.assign({}, options, {name: 'sensor'}));

	return {
		dimension,
		observedProjection,
		covariance(o) {
			const covariance = identity(dimension);
			const {variance} = o;

			variance.forEach((v, i) => {
				covariance[i][i] = v * baseCovariance[i][i];
			});

			return covariance;
		},
	};
};

module.exports = nullableSensor;



/***/ }),

/***/ "./lib/observation/sensor-projected.js":
/*!*********************************************!*\
  !*** ./lib/observation/sensor-projected.js ***!
  \*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {identity, matPermutation} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");
const correlationToCovariance = __webpack_require__(/*! ../utils/correlation-to-covariance */ "./lib/utils/correlation-to-covariance.js");
const covarianceToCorrelation = __webpack_require__(/*! ../utils/covariance-to-correlation */ "./lib/utils/covariance-to-correlation.js");

/**
*Creates an observation model with a observedProjection corresponding to
* @param {DynamicConfig} dynamic
* @param {ObservationConfig} observation
* @returns {DynamicConfig}
*/

const sensorProjected = function ({selectedCovariance, totalDimension, obsIndexes, selectedStateProjection}) {
	if (!selectedStateProjection) {
		selectedStateProjection = new Array(obsIndexes.length).fill(0).map(() => new Array(obsIndexes.length).fill(0));
		obsIndexes.forEach((index1, i1) => {
			selectedStateProjection[i1][i1] = 1;
		});
	} else if (selectedStateProjection.length !== obsIndexes.length) {
		throw (new Error(`[Sensor-projected] Shape mismatch between ${selectedStateProjection.length} and ${obsIndexes.length}`));
	}

	const baseCovariance = identity(totalDimension);
	obsIndexes.forEach((index1, i1) => {
		if (selectedCovariance) {
			obsIndexes.forEach((index2, i2) => {
				baseCovariance[index1][index2] = selectedCovariance[i1][i2];
			});
		}
	});
	const {correlation: baseCorrelation, variance: baseVariance} = covarianceToCorrelation(baseCovariance);

	const dynaDimension = selectedStateProjection[0].length;

	if (selectedStateProjection.length !== obsIndexes.length) {
		throw (new Error(`shape mismatch (${selectedStateProjection.length} vs ${obsIndexes.length})`));
	}

	const observedProjection = matPermutation({
		outputSize: [totalDimension, dynaDimension],
		colIndexes: selectedStateProjection[0].map((_, i) => i),
		rowIndexes: obsIndexes,
		matrix: selectedStateProjection,
	});

	return {
		dimension: totalDimension,
		observedProjection,
		covariance(o) {
			const {variance} = o;
			if (!variance) {
				return baseCovariance;
			}

			if (variance.length !== baseCovariance.length) {
				throw (new Error('variance is difference size from baseCovariance'));
			}

			const result = correlationToCovariance({correlation: baseCorrelation, variance: baseVariance.map((b, i) => variance[i] * b)});

			return result;
		},
	};
};

module.exports = sensorProjected;


/***/ }),

/***/ "./lib/observation/sensor.js":
/*!***********************************!*\
  !*** ./lib/observation/sensor.js ***!
  \***********************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {identity} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");
const polymorphMatrix = __webpack_require__(/*! ../utils/polymorph-matrix.js */ "./lib/utils/polymorph-matrix.js");
const checkMatrix = __webpack_require__(/*! ../utils/check-matrix.js */ "./lib/utils/check-matrix.js");

/**
* @param {Number} sensorDimension
* @param {CovarianceParam} sensorCovariance
* @param {Number} nSensors
* @returns {ObservationConfig}
*/

const copy = mat => mat.map(a => a.concat());

module.exports = function (options) {
	const {sensorDimension = 1, sensorCovariance = 1, nSensors = 1} = options;
	const sensorCovarianceFormatted = polymorphMatrix(sensorCovariance, {dimension: sensorDimension});
	checkMatrix(sensorCovarianceFormatted, [sensorDimension, sensorDimension], 'observation.sensorCovariance');
	const oneSensorObservedProjection = identity(sensorDimension);
	let concatenatedObservedProjection = [];
	const dimension = sensorDimension * nSensors;
	const concatenatedCovariance = identity(dimension);
	for (let i = 0; i < nSensors; i++) {
		concatenatedObservedProjection = concatenatedObservedProjection.concat(copy(oneSensorObservedProjection));

		for (const [rIndex, r] of sensorCovarianceFormatted.entries()) {
			for (const [cIndex, c] of r.entries()) {
				concatenatedCovariance[rIndex + (i * sensorDimension)][cIndex + (i * sensorDimension)] = c;
			}
		}
	}

	return Object.assign({}, options, {
		dimension,
		observedProjection: concatenatedObservedProjection,
		covariance: concatenatedCovariance,
	});
};


/***/ }),

/***/ "./lib/setup/build-state-projection.js":
/*!*********************************************!*\
  !*** ./lib/setup/build-state-projection.js ***!
  \*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {padWithZeroCols: padWithZeros} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");
const {identity} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");
/**
*Builds the stateProjection given an observedProjection
*@param {ObservationConfig} observation
*@param {DynamicConfig} dynamic
*@returns {ObservationConfig, DynamicConfig} the model containing the created stateProjection
*/

module.exports = function ({observation, dynamic}) {
	const {observedProjection, stateProjection} = observation;
	const observationDimension = observation.dimension;
	const dynamicDimension = dynamic.dimension;
	if (observedProjection && stateProjection) {
		throw (new TypeError('You cannot use both observedProjection and stateProjection'));
	}

	if (observedProjection) {
		const stateProjection = padWithZeros(observedProjection, {columns: dynamicDimension});
		return {
			observation: Object.assign({}, observation, {
				stateProjection,
			}),
			dynamic,
		};
	}

	if (observationDimension && dynamicDimension && !stateProjection) {
		const observationMatrix = identity(observationDimension);
		return {
			observation: Object.assign({}, observation, {
				stateProjection: padWithZeros(observationMatrix, {columns: dynamicDimension}),
			}),
			dynamic,
		};
	}

	return {observation, dynamic};
};


/***/ }),

/***/ "./lib/setup/check-dimensions.js":
/*!***************************************!*\
  !*** ./lib/setup/check-dimensions.js ***!
  \***************************************/
/***/ ((module) => {

/**
*Verifies that dynamic.dimension and observation.dimension are set
*@param {ObservationConfig} observation
*@param {DynamicConfig} dynamic
*/

module.exports = function ({observation, dynamic}) {
	const dynamicDimension = dynamic.dimension;
	const observationDimension = observation.dimension;
	if (!dynamicDimension || !observationDimension) {
		throw (new TypeError('Dimension is not set'));
	}

	return {observation, dynamic};
};


/***/ }),

/***/ "./lib/setup/extend-dynamic-init.js":
/*!******************************************!*\
  !*** ./lib/setup/extend-dynamic-init.js ***!
  \******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {diag} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");
const polymorphMatrix = __webpack_require__(/*! ../utils/polymorph-matrix.js */ "./lib/utils/polymorph-matrix.js");

/**
*Initializes the dynamic.init when not given
*@param {ObservationConfig} observation
*@param {DynamicConfig} dynamic
*@returns {CoreConfig}
*/

module.exports = function ({observation, dynamic}) {
	if (!dynamic.init) {
		const huge = 1e6;
		const dynamicDimension = dynamic.dimension;
		const meanArray = new Array(dynamicDimension).fill(0);
		const covarianceArray = new Array(dynamicDimension).fill(huge);
		const withInitOptions = {
			observation,
			dynamic: Object.assign({}, dynamic, {
				init: {
					mean: meanArray.map(element => [element]),
					covariance: diag(covarianceArray),
					index: -1,
				},
			}),
		};
		return withInitOptions;
	}

	if (dynamic.init && !dynamic.init.mean) {
		throw (new Error('dynamic.init should have a mean key'));
	}

	dynamic.init = Object.assign({}, dynamic.init, {
		covariance: polymorphMatrix(dynamic.init.covariance, {dimension: dynamic.dimension}),
	});

	return {observation, dynamic};
};


/***/ }),

/***/ "./lib/setup/set-dimensions.js":
/*!*************************************!*\
  !*** ./lib/setup/set-dimensions.js ***!
  \*************************************/
/***/ ((module) => {

/**
*Verifies that dimensions are matching and set dynamic.dimension and observation.dimension
* with respect of stateProjection and transition dimensions
*@param {ObservationConfig} observation
*@param {DynamicConfig} dynamic
*@returns {ObservationConfig, DynamicConfig}
*/

module.exports = function ({observation, dynamic}) {
	const {stateProjection} = observation;
	const {transition} = dynamic;
	const dynamicDimension = dynamic.dimension;
	const observationDimension = observation.dimension;

	if (dynamicDimension && observationDimension && Array.isArray(stateProjection) && (dynamicDimension !== stateProjection[0].length || observationDimension !== stateProjection.length)) {
		throw (new TypeError('stateProjection dimensions not matching with observation and dynamic dimensions'));
	}

	if (dynamicDimension && Array.isArray(transition) && dynamicDimension !== transition.length) {
		throw (new TypeError('transition dimension not matching with dynamic dimension'));
	}

	if (Array.isArray(stateProjection)) {
		return {
			observation: Object.assign({}, observation, {
				dimension: stateProjection.length,
			}),
			dynamic: Object.assign({}, dynamic, {
				dimension: stateProjection[0].length,
			}),
		};
	}

	if (Array.isArray(transition)) {
		return {
			observation,
			dynamic: Object.assign({}, dynamic, {
				dimension: transition.length,
			}),
		};
	}

	return {observation, dynamic};
};


/***/ }),

/***/ "./lib/state.js":
/*!**********************!*\
  !*** ./lib/state.js ***!
  \**********************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const {subtract: sub, transpose, matMul, invert, elemWise, subSquareMatrix} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");
const arrayToMatrix = __webpack_require__(/*! ./utils/array-to-matrix.js */ "./lib/utils/array-to-matrix.js");
const checkMatrix = __webpack_require__(/*! ./utils/check-matrix.js */ "./lib/utils/check-matrix.js");
const checkCovariance = __webpack_require__(/*! ./utils/check-covariance */ "./lib/utils/check-covariance.js");

/**
 * Class representing a multi dimensionnal gaussian, with his mean and his covariance
 * @property {Number} [index=0] the index of the State in the process, this is not mandatory for simple Kalman Filter, but is needed for most of the use case of extended kalman filter
 * @property {Array.<Array.<Number>>} covariance square matrix of size dimension
 * @property {Array.<Array<Number>>} mean column matrix of size dimension x 1
 */
class State {
	constructor({mean, covariance, index}) {
		this.mean = mean;
		this.covariance = covariance;
		this.index = index;
	}

	/**
	* Check the consistency of the State
	* @param {Object} options
	* @returns {Null}
	* @see check
	*/
	check(options) {
		this.constructor.check(this, options);
	}

	/**
	* Check the consistency of the State's attributes
	* @param {State} state
	* @param {Object} [options={}]
	* @param {Array} [options.dimension=null] if defined check the dimension of the state
	* @param {String} [options.title=null] used to log error mor explicitly
	* @param {Boolean} options.eigen
	* @returns {Null}
	*/

	static check(state, {dimension = null, title = null, eigen} = {}) {
		if (!(state instanceof State)) {
			throw (new TypeError(
				'The argument is not a state \n'
        + 'Tips: maybe you are using 2 different version of kalman-filter in your npm deps tree',
			));
		}

		const {mean, covariance} = state; // Index
		const meanDimension = mean.length;
		if (typeof (dimension) === 'number' && meanDimension !== dimension) {
			throw (new Error(`[${title}] State.mean ${mean} with dimension ${meanDimension} does not match expected dimension (${dimension})`));
		}

		checkMatrix(mean, [meanDimension, 1], title ? title + '.mean' : 'mean');
		checkMatrix(covariance, [meanDimension, meanDimension], title ? title + '.covariance' : 'covariance');
		checkCovariance({covariance, eigen}, title ? title + '.covariance' : 'covariance');
		// If (typeof (index) !== 'number') {
		// 	throw (new TypeError('t must be a number'));
		// }
	}

	/**
	* Multiply state with matrix
	* @param {State} state
	* @param {Array.<Array.<Number>>} matrix
	* @returns {State}
	*/
	static matMul({state, matrix}) {
		const covariance = matMul(
			matMul(matrix, state.covariance),
			transpose(matrix),
		);
		const mean = matMul(matrix, state.mean);

		return new State({
			mean,
			covariance,
			index: state.index,
		});
	}

	/**
	* From a state in n-dimension create a state in a subspace
	* If you see the state as a N-dimension gaussian,
	* this can be viewed as the sub M-dimension gaussian (M < N)
	* @param {Array.<Number>} obsIndexes list of dimension to extract,  (M < N <=> obsIndexes.length < this.mean.length)
	* @returns {State} subState in subspace, with subState.mean.length === obsIndexes.length
	*/
	subState(obsIndexes) {
		const state = new State({
			mean: obsIndexes.map(i => this.mean[i]),
			covariance: subSquareMatrix(this.covariance, obsIndexes),
			index: this.index,
		});
		return state;
	}

	/**
	* @typedef {Object} DetailedMahalanobis
	* @property {Array.<[Number]>} diff
	* @property {Array.<Array.<Number>>} covarianceInvert
	* @property {Number} value
	*/
	/**
	* Simple Malahanobis distance between the distribution (this) and a point
	* @param {Array.<[Number]>} point a Nx1 matrix representing a point
	* @returns {DetailedMahalanobis}
	*/
	rawDetailedMahalanobis(point) {
		const diff = sub(this.mean, point);
		this.check();
		const covarianceInvert = invert(this.covariance);
		if (covarianceInvert === null) {
			this.check({eigen: true});
			throw (new Error(`Cannot invert covariance ${JSON.stringify(this.covariance)}`));
		}

		const diffTransposed = transpose(diff);

		// Console.log('covariance in obs space', covarianceInObservationSpace);

		const value = Math.sqrt(
			matMul(
				matMul(
					diffTransposed,
					covarianceInvert,
				),
				diff,
			),
		);
		if (Number.isNaN(value)) {
			console.log({diff, covarianceInvert, this: this, point}, matMul(
				matMul(
					diffTransposed,
					covarianceInvert,
				),
				diff,
			));
			throw (new Error('mahalanobis is NaN'));
		}

		return {
			diff,
			covarianceInvert,
			value,
		};
	}

	/**
	* Malahanobis distance is made against an observation, so the mean and covariance
	* are projected into the observation space
	* @param {KalmanFilter} kf kalman filter use to project the state in observation's space
	* @param {Observation} observation
	* @param {Array.<Number>} obsIndexes list of indexes of observation state to use for the mahalanobis distance
	* @returns {DetailedMahalanobis}
	*/
	detailedMahalanobis({kf, observation, obsIndexes}) {
		if (observation.length !== kf.observation.dimension) {
			throw (new Error(`Mahalanobis observation ${observation} (dimension: ${observation.length}) does not match with kf observation dimension (${kf.observation.dimension})`));
		}

		let correctlySizedObservation = arrayToMatrix({observation, dimension: observation.length});

		const stateProjection = kf.getValue(kf.observation.stateProjection, {});

		let projectedState = this.constructor.matMul({state: this, matrix: stateProjection});

		if (Array.isArray(obsIndexes)) {
			projectedState = projectedState.subState(obsIndexes);
			correctlySizedObservation = obsIndexes.map(i => correctlySizedObservation[i]);
		}

		return projectedState.rawDetailedMahalanobis(correctlySizedObservation);
	}

	/**
	* @param {Object} options @see detailedMahalanobis
	* @returns {Number}
	*/
	mahalanobis(options) {
		const result = this.detailedMahalanobis(options).value;
		if (Number.isNaN(result)) {
			throw (new TypeError('mahalanobis is NaN'));
		}

		return result;
	}

	/**
	* Bhattacharyya distance is made against in the observation space
	* to do it in the normal space see state.bhattacharyya
	* @param {KalmanFilter} kf kalman filter use to project the state in observation's space
	* @param {State} state
	* @param {Array.<Number>} obsIndexes list of indexes of observation state to use for the bhattacharyya distance
	* @returns {Number}
	*/
	obsBhattacharyya({kf, state, obsIndexes}) {
		const stateProjection = kf.getValue(kf.observation.stateProjection, {});

		let projectedSelfState = this.constructor.matMul({state: this, matrix: stateProjection});
		let projectedOtherState = this.constructor.matMul({state, matrix: stateProjection});

		if (Array.isArray(obsIndexes)) {
			projectedSelfState = projectedSelfState.subState(obsIndexes);
			projectedOtherState = projectedOtherState.subState(obsIndexes);
		}

		return projectedSelfState.bhattacharyya(projectedOtherState);
	}

	/**
	* @param {State} otherState other state to compare with
	* @returns {Number}
	*/
	bhattacharyya(otherState) {
		const {covariance, mean} = this;
		const average = elemWise([covariance, otherState.covariance], ([a, b]) => (a + b) / 2);

		let covarInverted;
		try {
			covarInverted = invert(average);
		} catch (error) {
			console.log('Cannot invert', average);
			throw (error);
		}

		const diff = sub(mean, otherState.mean);

		return matMul(transpose(diff), matMul(covarInverted, diff))[0][0];
	}
}

module.exports = State;


/***/ }),

/***/ "./lib/utils/array-to-matrix.js":
/*!**************************************!*\
  !*** ./lib/utils/array-to-matrix.js ***!
  \**************************************/
/***/ ((module) => {

/**
*Returns the corresponding matrix in dim*1, given an dim matrix, and checks
* if corresponding with the observation dimension
*@param {Array.<Number> | Array.<Array.<Number>>} observation
*@param {Number} dimension
*@returns {Array.<Array.<Number>>}
*/

module.exports = function ({observation, dimension}) {
	if (!Array.isArray(observation)) {
		if (dimension === 1 && typeof (observation) === 'number') {
			return [[observation]];
		}

		throw (new TypeError(`The observation (${observation}) should be an array (dimension: ${dimension})`));
	}

	if (observation.length !== dimension) {
		throw (new TypeError(`Observation (${observation.length}) and dimension (${dimension}) not matching`));
	}

	if (typeof (observation[0]) === 'number' || observation[0] === null) {
		return observation.map(element => [element]);
	}

	return observation;
};


/***/ }),

/***/ "./lib/utils/check-covariance.js":
/*!***************************************!*\
  !*** ./lib/utils/check-covariance.js ***!
  \***************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const tolerance = 0.1;
const Matrix = __webpack_require__(/*! @rayyamhk/matrix */ "./node_modules/@rayyamhk/matrix/lib/index.js");
const checkMatrix = __webpack_require__(/*! ./check-matrix */ "./lib/utils/check-matrix.js");

const checkDefinitePositive = function (covariance, tolerance = 1e-10) {
	const covarianceMatrix = new Matrix(covariance);
	const eigenvalues = covarianceMatrix.eigenvalues();
	for (const eigenvalue of eigenvalues) {
		if (eigenvalue <= -tolerance) {
			console.log(covariance, eigenvalue);
			throw new Error(`Eigenvalue should be positive (actual: ${eigenvalue})`);
		}
	}

	console.log('is definite positive', covariance);
};

const checkSymetric = function (covariance, title = 'checkSymetric') {
	for (const [rowId, row] of covariance.entries()) {
		for (const [colId, item] of row.entries()) {
			if (rowId === colId && item < 0) {
				throw new Error(`[${title}] Variance[${colId}] should be positive (actual: ${item})`);
			} else if (Math.abs(item) > Math.sqrt(covariance[rowId][rowId] * covariance[colId][colId])) {
				console.log(covariance);
				throw new Error(`[${title}] Covariance[${rowId}][${colId}] should verify Cauchy Schwarz Inequality `
				+ `(expected: |x| <= sqrt(${covariance[rowId][rowId]} * ${covariance[colId][colId]})`
				+ ` actual: ${item})`);
			} else if (Math.abs(item - covariance[colId][rowId]) > tolerance) {
				throw new Error(`[${title}] Covariance[${rowId}][${colId}] should equal Covariance[${colId}][${rowId}] `
			+ ` (actual diff: ${Math.abs(item - covariance[colId][rowId])})  = ${item} - ${covariance[colId][rowId]}\n`
			+ `${covariance.join('\n')} is invalid`,
				);
			}
		}
	}
};

module.exports = function ({covariance, eigen = false}) {
	checkMatrix(covariance);
	checkSymetric(covariance);
	if (eigen) {
		checkDefinitePositive(covariance);
	}
};


/***/ }),

/***/ "./lib/utils/check-matrix.js":
/*!***********************************!*\
  !*** ./lib/utils/check-matrix.js ***!
  \***********************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const checkShape = __webpack_require__(/*! ./check-shape */ "./lib/utils/check-shape.js");

module.exports = function (matrix, shape, title = 'checkMatrix') {
	if (!Array.isArray(matrix)) {
		throw (new TypeError(`[${title}] should be a 2-level array matrix and is ${matrix}`));
	}

	for (const row of matrix) {
		if (!Array.isArray(row)) {
			throw (new TypeError(`[${title}] 1-level array should be a matrix ${JSON.stringify(matrix)}`));
		}
	}

	if (matrix.reduce((a, b) => a.concat(b)).some(a => Number.isNaN(a))) {
		throw (new Error(
			`[${title}] Matrix should not have a NaN\nIn : \n`
			+ matrix.join('\n'),
		));
	}

	if (shape) {
		checkShape(matrix, shape, title);
	}
};


/***/ }),

/***/ "./lib/utils/check-shape.js":
/*!**********************************!*\
  !*** ./lib/utils/check-shape.js ***!
  \**********************************/
/***/ ((module) => {

const checkShape = function (matrix, shape, title = 'checkShape') {
	if (matrix.length !== shape[0]) {
		throw (new Error(`[${title}] expected size (${shape[0]}) and length (${matrix.length}) does not match`));
	}

	if (shape.length > 1) {
		return matrix.forEach(m => checkShape(m, shape.slice(1), title));
	}
};

module.exports = checkShape;


/***/ }),

/***/ "./lib/utils/correlation-to-covariance.js":
/*!************************************************!*\
  !*** ./lib/utils/correlation-to-covariance.js ***!
  \************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const checkCovariance = __webpack_require__(/*! ./check-covariance */ "./lib/utils/check-covariance.js");

module.exports = function ({correlation, variance}) {
	checkCovariance({covariance: correlation});
	return correlation.map((c, rowIndex) => c.map((a, colIndex) => a * Math.sqrt(variance[colIndex] * variance[rowIndex])));
};


/***/ }),

/***/ "./lib/utils/covariance-to-correlation.js":
/*!************************************************!*\
  !*** ./lib/utils/covariance-to-correlation.js ***!
  \************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const checkCovariance = __webpack_require__(/*! ./check-covariance */ "./lib/utils/check-covariance.js");

module.exports = function (covariance) {
	checkCovariance({covariance});
	const variance = covariance.map((_, i) => covariance[i][i]);

	return {
		variance,
		correlation: covariance.map((c, rowIndex) => c.map((a, colIndex) => a / Math.sqrt(variance[colIndex] * variance[rowIndex]))),
	};
};


/***/ }),

/***/ "./lib/utils/deep-assign.js":
/*!**********************************!*\
  !*** ./lib/utils/deep-assign.js ***!
  \**********************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const uniq = __webpack_require__(/*! ./uniq.js */ "./lib/utils/uniq.js");

const limit = 100;

/**
*Equivalent to the Object.assign method, takes several arguments and creates a new object corresponding to the assignment of the arguments
* @param {Object} args
* @param {Number} step
* @returns {Object}
*/
const deepAssign = function (args, step) {
	if (step > limit) {
		throw (new Error(`In deepAssign, number of recursive call (${step}) reached limit (${limit}), deepAssign is not working on  self-referencing objects`));
	}

	const filterArguments = args.filter(arg => (arg) !== undefined && arg !== null);
	const lastArgument = filterArguments[filterArguments.length - 1];
	if (filterArguments.length === 1) {
		return filterArguments[0];
	}

	if (typeof (lastArgument) !== 'object' || Array.isArray(lastArgument)) {
		return lastArgument;
	}

	if (filterArguments.length === 0) {
		return null;
	}

	const objectsArguments = filterArguments.filter(arg => typeof (arg) === 'object');
	let keys = [];
	for (const arg of objectsArguments) {
		keys = keys.concat(Object.keys(arg));
	}

	const uniqKeys = uniq(keys);
	const result = {};
	for (const key of uniqKeys) {
		const values = objectsArguments.map(arg => arg[key]);
		result[key] = deepAssign(values, step + 1);
	}

	return result;
};

module.exports = ((...args) => deepAssign(args, 0));


/***/ }),

/***/ "./lib/utils/get-covariance.js":
/*!*************************************!*\
  !*** ./lib/utils/get-covariance.js ***!
  \*************************************/
/***/ ((module) => {

/**
* @param {Object} opts
* @param {Array.<Array.<Number>>} opts.measures a list of measure, size is LxN L the number of sample, N the dimension
* @param {Array.<Array.<Number>>} opts.averages a list of averages, size is LxN L the number of sample, N the dimension
* @returns {Array.<Array.<Number>>} covariance matrix size is NxN
*/

module.exports = function ({measures, averages}) {
	const l = measures.length;
	const n = measures[0].length;

	if (l === 0) {
		throw (new Error('Cannot find covariance for empty sample'));
	}

	return (new Array(n).fill(1)).map((_, rowIndex) => (new Array(n).fill(1)).map((_, colIndex) => {
		const stds = measures.map((m, i) => (m[rowIndex] - averages[i][rowIndex]) * (m[colIndex] - averages[i][colIndex]));
		const result = stds.reduce((a, b) => a + b) / l;
		if (Number.isNaN(result)) {
			throw (new TypeError('result is NaN'));
		}

		return result;
	}));
};


/***/ }),

/***/ "./lib/utils/polymorph-matrix.js":
/*!***************************************!*\
  !*** ./lib/utils/polymorph-matrix.js ***!
  \***************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

/**
* @typedef {Number | Array.<Number> | Array.<Array.<Number>>} CovarianceParam
*/
const {diag} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");
const checkMatrix = __webpack_require__(/*! ./check-matrix */ "./lib/utils/check-matrix.js");
/**
* If cov is a number, result will be Identity*cov
* If cov is an Array.<Number>, result will be diag(cov)
* If cov is an Array.<Array.<Number>>, result will be cov
* @param {CovarianceParam} cov
* @param {Number} dimension
* @returns {Array.<Array.<Number>>}
*/
module.exports = function (cov, {dimension, title = 'polymorph'} = {}) {
	if (typeof (cov) === 'number' || Array.isArray(cov)) {
		if (typeof (cov) === 'number' && typeof (dimension) === 'number') {
			return diag(new Array(dimension).fill(cov));
		}

		if ((Array.isArray(cov)) && (Array.isArray(cov[0]))) {
			let shape;
			if (typeof (dimension) === 'number') {
				shape = [dimension, dimension];
			}

			checkMatrix(cov, shape, title);
			return cov;
		}

		if ((Array.isArray(cov)) && (typeof (cov[0]) === 'number')) {
			return diag(cov);
		}
	}

	return cov;
};


/***/ }),

/***/ "./lib/utils/project-observation.js":
/*!******************************************!*\
  !*** ./lib/utils/project-observation.js ***!
  \******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// From observationTracks to movingAverageGroundTruthsStates with speed

const {matMul, invert} = __webpack_require__(/*! simple-linalg */ "./node_modules/simple-linalg/index.js");

module.exports = function ({observation, obsIndexes, selectedStateProjection, invertSelectedStateProjection}) {
	if (!observation) {
		return null;
	}

	const value = observation.observation || observation;

	const vec = obsIndexes.map(i => {
		if ((value[i]) === undefined) {
			throw (new TypeError(`obsIndexes (${obsIndexes}) is not matching with observation (${observation})`));
		}

		return [value[i]];
	});

	const inverse = invertSelectedStateProjection || invert(selectedStateProjection);

	if (inverse === null) {
		throw (new Error('selectedStateProjection is not invertible, please provide invertSelectedStateProjection'));
	}

	const out = matMul(inverse, vec);

	return out
		.map(v => v[0])
		.map(v => {
			if (Number.isNaN(v)) {
				throw (new TypeError('NaN in projection'));
			}

			return v;
		});
};


/***/ }),

/***/ "./lib/utils/to-function.js":
/*!**********************************!*\
  !*** ./lib/utils/to-function.js ***!
  \**********************************/
/***/ ((module) => {

// Const {diag} = require('simple-linalg');;

/**
* @callback MatrixCallback
* @returns <Array.<Array.<Number>>
*/

/**
* Tranforms:
** a 2d array into a function (() => array)
** a 1d array into a function (() => diag(array))
*@param {Array.<Number> | Array.<Array.<Number>>} array
*@returns {MatrixCallback}
*/

module.exports = function (array, {label = null} = {}) {
	if (typeof (array) === 'function') {
		return array;
	}

	if (Array.isArray(array)) {
		return array;
	}

	throw (new Error(`${label === null ? '' : label + ' : '}Only arrays and functions are authorized (got: "${array}")`));
};


/***/ }),

/***/ "./lib/utils/uniq.js":
/*!***************************!*\
  !*** ./lib/utils/uniq.js ***!
  \***************************/
/***/ ((module) => {

module.exports = function (array) {
	return array.filter((value, index) =>
		array.indexOf(value) === index,
	);
};


/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/instance/getArgument.js":
/*!*************************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/instance/getArgument.js ***!
  \*************************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the argument of a Complex Number which is restricted to the interval [ 0, 2π ).<br><br>
 * 
 * The argument of the Complex Number is the angle between positive real-axis
 * and the vector representing the Complex Number on Complex plane.<br><br>
 * 
 * If the given Complex Number is considered as 0, returns undefined.
 * @memberof Complex
 * @instance
 * @returns {number} The argument of the Complex Number
 */
function getArgument() {
  var x = this.re;
  var y = this.im;
  var epsilon = 1 / (Math.pow(10, 15) * 2);

  if (Math.abs(x) < epsilon && Math.abs(y) < epsilon) {
    return undefined;
  }

  if (x === 0) {
    if (y > 0) {
      return Math.PI * 0.5;
    }

    return Math.PI * 1.5;
  }

  if (y === 0) {
    if (x > 0) {
      return 0;
    }

    return Math.PI;
  }

  if (x > 0 && y > 0) {
    return Math.atan(y / x);
  }

  if (x < 0 && y > 0) {
    return Math.PI - Math.atan(y / (x * -1));
  }

  if (x < 0 && y < 0) {
    return Math.PI + Math.atan(y * -1 / (x * -1));
  }

  return Math.PI * 2 - Math.atan(y * -1 / x);
}

module.exports = getArgument;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/instance/getImaginary.js":
/*!**************************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/instance/getImaginary.js ***!
  \**************************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Gets the imaginary part of a Complex Number.
 * @memberof Complex
 * @instance
 * @returns {number} The imaginary part of the Complex Number
 */
function getImaginary() {
  return this.im;
}

module.exports = getImaginary;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/instance/getModulus.js":
/*!************************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/instance/getModulus.js ***!
  \************************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the modulus of a Complex Number.<br><br>
 * 
 * The modulus of the complex number is the length of the vector
 * representing the complex number on complex plane.
 * @memberof Complex
 * @instance
 * @returns {number} The modulus of the Complex Number
 */
function getModulus() {
  return Math.sqrt(Math.pow(this.re, 2) + Math.pow(this.im, 2));
}

module.exports = getModulus;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/instance/getReal.js":
/*!*********************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/instance/getReal.js ***!
  \*********************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Gets the real part of a Complex Number.
 * @memberof Complex
 * @instance
 * @returns {number} The real part of the Complex Number
 */
function getReal() {
  return this.re;
}

module.exports = getReal;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/instance/toString.js":
/*!**********************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/instance/toString.js ***!
  \**********************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Gets the stringified and formatted Complex Number.
 * @memberof Complex
 * @instance
 * @returns {string} The stringified and formatted Complex Number
 */
function toString() {
  var re = this.re,
      im = this.im;

  if (Number.isNaN(re) || Number.isNaN(im)) {
    return 'NaN';
  }

  if (re === 0 && im === 0) {
    return '0';
  }

  if (re === 0) {
    if (im === 1) {
      return 'i';
    }

    if (im === -1) {
      return '-i';
    }

    return "".concat(im, "i");
  }

  if (im === 0) {
    return "".concat(re);
  }

  if (im > 0) {
    if (im === 1) {
      return "".concat(re, " + i");
    }

    return "".concat(re, " + ").concat(im, "i");
  }

  if (im === -1) {
    return "".concat(re, " - i");
  }

  return "".concat(re, " - ").concat(Math.abs(im), "i");
}

module.exports = toString;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/acos.js":
/*!****************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/acos.js ***!
  \****************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the inverse cosine of a Complex Number.
 * @memberof Complex
 * @static
 * @param {Complex} num - Any Complex Number
 * @returns {Complex} The result of inverse cosine function
 */
function acos(num) {
  return this.subtract(new this(Math.PI / 2), this.asin(num));
}

module.exports = acos;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/acot.js":
/*!****************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/acot.js ***!
  \****************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the inverse cotangent of a Complex Number.
 * The domain of this function is C / { i , -i , 0 }.<br><br>
 * 
 * If the argument is out of its domain, it returns Complex.NaN.
 * @memberof Complex
 * @static
 * @param {Complex} num - Any Complex Number except i, -i and 0
 * @returns {Complex} The result of inverse cotangent function
 */
function acot(num) {
  return this.atan(this.inverse(num));
}

module.exports = acot;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/acsc.js":
/*!****************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/acsc.js ***!
  \****************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the inverse cosecant of a Complex Number.
 * The domain of this function is C / { 0 }.<br><br>
 * 
 * If the argument is out of its domain, it returns Complex.NaN.
 * @memberof Complex
 * @static
 * @param {Complex} num - Any Complex Number except 0
 * @returns {Complex} The result of inverse cosecant function
 */
function acsc(num) {
  return this.asin(this.inverse(num));
}

module.exports = acsc;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/add.js":
/*!***************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/add.js ***!
  \***************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the sum of two Complex Number.
 * @memberof Complex
 * @static
 * @param {Complex} num1 - The Complex Number on the left of '+' operator.
 * @param {Complex} num2 - The Complex Number on the right of '+' operator.
 * @returns {Complex} The sum of two Complex Numbers
 */
function add(num1, num2) {
  if (!(num1 instanceof this) || !(num2 instanceof this)) {
    return this.NaN;
  }

  return new this(num1.re + num2.re, num1.im + num2.im);
}

module.exports = add;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/asec.js":
/*!****************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/asec.js ***!
  \****************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the inverse secant of a Complex Number.
 * The domain of this function is C / { 0 }.<br><br>
 * 
 * If the argument is out of its domain, it returns Complex.NaN.
 * @memberof Complex
 * @static
 * @param {Complex} num - Any Complex Number except 0
 * @returns {Complex} The result of inverse secant function
 */
function asec(num) {
  return this.acos(this.inverse(num));
}

module.exports = asec;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/asin.js":
/*!****************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/asin.js ***!
  \****************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the inverse sine of a Complex Number.
 * @memberof Complex
 * @static
 * @param {Complex} num - Any Complex Number
 * @returns {Complex} The result of inverse sine function
 */
function asin(num) {
  return this.multiply(new this(0, -1), this.log(this.add(this.multiply(new this(0, 1), num), this.pow(this.subtract(this.ONE, this.pow(num, 2)), 0.5))));
}

module.exports = asin;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/atan.js":
/*!****************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/atan.js ***!
  \****************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the inverse tangent of a Complex Number.
 * The domain of this function is C / { i , -i }.<br><br>
 * 
 * If the argument is out of its domain, it returns Complex.NaN.
 * @memberof Complex
 * @static
 * @param {Complex} num - Any Complex Number except i and -i
 * @returns {Complex} The result of inverse tangent function
 */
function atan(num) {
  return this.multiply(new this(0, 1 / 2), this.subtract(this.log(this.subtract(this.ONE, this.multiply(new this(0, 1), num))), this.log(this.add(this.ONE, this.multiply(new this(0, 1), num)))));
}

module.exports = atan;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/conjugate.js":
/*!*********************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/conjugate.js ***!
  \*********************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the complex conjugate of the Complex Number.
 * @memberof Complex
 * @static
 * @param {Complex} num - Complex number
 * @returns {Complex} The complex conjugate of the Complex Number
 */
function conjugate(num) {
  if (!(num instanceof this)) {
    return this.NaN;
  }

  return new this(num.getReal(), num.getImaginary() * -1);
}

module.exports = conjugate;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/cos.js":
/*!***************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/cos.js ***!
  \***************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the cosine of a Complex Number.
 * @memberof Complex
 * @static
 * @param {Complex} num - Any Complex Number
 * @returns {Complex} The result of cosine function
 */
function cos(num) {
  if (!(num instanceof this)) {
    return this.NaN;
  }

  var a = num.getReal();
  var b = num.getImaginary();
  return new this(Math.cos(a) * Math.cosh(b), Math.sin(a) * Math.sinh(b) * -1);
}

module.exports = cos;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/cot.js":
/*!***************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/cot.js ***!
  \***************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the cotangent of a Complex Number.
 * The domain of this function is C / { kπ/2 : k is any integer }.<br><br>
 * 
 * If the argument is out of its domain, it returns Complex.NaN.
 * @memberof Complex
 * @static
 * @param {Complex} num - Any Complex Number which is not the multiple of π/2
 * @returns {Complex} The result of cotangent function
 */
function cot(num) {
  return this.divide(this.ONE, this.tan(num));
}

module.exports = cot;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/csc.js":
/*!***************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/csc.js ***!
  \***************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the cosecant of a Complex Number.
 * The domain of this function is C / { kπ : k is any integer }.<br><br>
 * 
 * If the argument is out of its domain, it returns Complex.NaN.
 * @memberof Complex
 * @static
 * @param {Complex} num - Any Complex Number which is not the multiple of π
 * @returns {Complex} The result of cosecant function
 */
function csc(num) {
  return this.divide(this.ONE, this.sin(num));
}

module.exports = csc;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/divide.js":
/*!******************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/divide.js ***!
  \******************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the quotient of two Complex Number.<br><br>
 * 
 * Note that if the denominator is considered as 0,
 * returns Complex.NaN instead of Infinity.
 * @memberof Complex
 * @static
 * @param {Complex} num1 - The Complex Number on the left of '/' operator.
 * @param {Complex} num2 - The Complex Number on the right of '/' operator.
 * @returns {Complex} The quotient of two Complex Numbers
 */
function divide(num1, num2) {
  if (!(num1 instanceof this) || !(num2 instanceof this)) {
    return this.NaN;
  }

  var a = num1.re;
  var b = num1.im;
  var c = num2.re;
  var d = num2.im;

  if (Math.abs(c) < this.EPSILON && Math.abs(d) < this.EPSILON) {
    return this.NaN;
  }

  var denominator = Math.pow(c, 2) + Math.pow(d, 2);
  return new this((a * c + b * d) / denominator, (b * c - a * d) / denominator);
}

module.exports = divide;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/exp.js":
/*!***************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/exp.js ***!
  \***************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the exponential function with base E.
 * @memberof Complex
 * @static
 * @param {Complex} num - Exponent
 * @returns {Complex} The value of E to the power of num
 */
function exp(num) {
  if (!(num instanceof this)) {
    return this.NaN;
  }

  var re = num.getReal();
  var theta = num.getImaginary();
  var r = Math.exp(re);
  return new this(r * Math.cos(theta), r * Math.sin(theta));
}

module.exports = exp;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/inverse.js":
/*!*******************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/inverse.js ***!
  \*******************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the inverse of the Complex Number.
 * @memberof Complex
 * @static
 * @param {Complex} num - Complex Number
 * @returns {number} Inverse of the Complex Number
 */
function inverse(num) {
  if (!(num instanceof this)) {
    return this.NaN;
  }

  return this.divide(this.ONE, num);
}

module.exports = inverse;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/isEqual.js":
/*!*******************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/isEqual.js ***!
  \*******************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Determines whether two Complex Numbers are considered as identical.<br><br>
 * 
 * Two Complex Numbers are considered as identical if either
 * both are NaN or both real and imaginary parts are extremely closed.<br><br>
 * 
 * The test criterion is Math.abs(x - y) < 1 / (10 ** digit * 2).
 * For default value 15, it should be 5e-16.
 * That means if the difference of two numbers is less than 5e-16,
 * they are considered as same value.
 * @memberof Complex
 * @static
 * @param {Complex} num1 - Complex Number
 * @param {Complex} num2 - Complex Number
 * @param {number} [digit=15] - Number of significant digits
 * @returns {boolean} Returns true if two Complex Numbers are considered as identical
 */
function isEqual(num1, num2) {
  var digit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 15;

  if (!(num1 instanceof this) || !(num2 instanceof this)) {
    return false;
  }

  if (!Number.isInteger(digit) || digit < 0) {
    throw new Error('Invalid argument: Expected a non-negative integer digit');
  }

  var EPSILON = 1 / (Math.pow(10, digit) * 2);
  var a = num1.getReal();
  var b = num1.getImaginary();
  var c = num2.getReal();
  var d = num2.getImaginary();

  if (Number.isNaN(a) && Number.isNaN(b) && Number.isNaN(c) && Number.isNaN(d)) {
    return true;
  }

  return Math.abs(a - c) < EPSILON && Math.abs(b - d) < EPSILON;
}

module.exports = isEqual;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/isNaN.js":
/*!*****************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/isNaN.js ***!
  \*****************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Determines whether the Complex Number is NaN or not.
 * @memberof Complex
 * @static
 * @param {Complex} num - Any Complex number
 * @returns {boolean} Returns true if one of real and imaginary part are NaN
 */
function isNaN(num) {
  if (!(num instanceof this)) {
    return false;
  }

  var re = num.getReal();
  var im = num.getImaginary();

  if (Number.isNaN(re) || Number.isNaN(im)) {
    return true;
  }

  return false;
}

module.exports = isNaN;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/log.js":
/*!***************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/log.js ***!
  \***************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the natural log of the Complex Number.<br><br>
 * 
 * Note that complex log is a multivalued function,
 * and this function only provides the principal value by
 * restricting the imaginary part to the interval [0, 2π).
 * @memberof Complex
 * @static
 * @param {Complex} num - Complex Number
 * @returns {number} Natural log of the Complex Number
 */
function log(num) {
  if (!(num instanceof this)) {
    return this.NaN;
  }

  var r = num.getModulus();
  var theta = num.getArgument();

  if (r < this.EPSILON || theta === undefined) {
    return this.NaN;
  }

  return new this(Math.log(r), theta);
}

module.exports = log;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/multiply.js":
/*!********************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/multiply.js ***!
  \********************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the product of two Complex Number.
 * @memberof Complex
 * @static
 * @param {Complex} num1 - The Complex Number on the left of '*' operator.
 * @param {Complex} num2 - The Complex Number on the right of '*' operator.
 * @returns {Complex} The product of two Complex Numbers
 */
function multiply(num1, num2) {
  if (!(num1 instanceof this) || !(num2 instanceof this)) {
    return this.NaN;
  }

  var a = num1.re;
  var b = num1.im;
  var c = num2.re;
  var d = num2.im;
  return new this(a * c - b * d, a * d + b * c);
}

module.exports = multiply;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/pow.js":
/*!***************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/pow.js ***!
  \***************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the power of the Complex Number.
 * The exponent can be any real number or Complex Number<br><br>
 * 
 * You can find the k-th root of complex number by setting the exponent to 1 / k.
 * But you should know that it only returns one out of k possible solutions.
 * @memberof Complex
 * @static
 * @param {Complex} num - Base
 * @param {Complex|number} n - Exponent
 * @returns {Complex} The result of the exponentiation
 */
function pow(num, n) {
  if (!(num instanceof this) || typeof n !== 'number' && !(n instanceof this)) {
    return this.NaN;
  }

  if (typeof n === 'number') {
    if (!Number.isFinite(n) || Number.isNaN(n)) {
      return this.NaN;
    }

    if (n === 0) {
      return this.ONE;
    }

    if (this.isEqual(num, this.ZERO)) {
      return this.ZERO;
    }

    return this.exp(this.multiply(new this(n, 0), this.log(num)));
  }

  if (n instanceof this) {
    return this.exp(this.multiply(n, this.log(num)));
  }

  return this.NaN;
}

module.exports = pow;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/sec.js":
/*!***************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/sec.js ***!
  \***************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the secant of a Complex Number.
 * The domain of this function is C / { (k + 0.5)π : k is any integer }.<br><br>
 * 
 * If the argument is out of its domain, it returns Complex.NaN.
 * @memberof Complex
 * @static
 * @param {Complex} num - Any Complex Number which is not in the form of (k + 0.5)π
 * @returns {Complex} The result of secant function
 */
function sec(num) {
  return this.divide(this.ONE, this.cos(num));
}

module.exports = sec;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/sin.js":
/*!***************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/sin.js ***!
  \***************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the sine of a Complex Number.
 * @memberof Complex
 * @static
 * @param {Complex} num - Any Complex Number
 * @returns {Complex} The result of sine function
 */
function sin(num) {
  if (!(num instanceof this)) {
    return this.NaN;
  }

  var a = num.getReal();
  var b = num.getImaginary();
  return new this(Math.sin(a) * Math.cosh(b), Math.cos(a) * Math.sinh(b));
}

module.exports = sin;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/subtract.js":
/*!********************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/subtract.js ***!
  \********************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the difference of two Complex Number.
 * @memberof Complex
 * @static
 * @param {Complex} num1 - The Complex Number on the left of '-' operator.
 * @param {Complex} num2 - The Complex Number on the right of '-' operator.
 * @returns {Complex} The difference of two Complex Numbers
 */
function subtract(num1, num2) {
  if (!(num1 instanceof this) || !(num2 instanceof this)) {
    return this.NaN;
  }

  return new this(num1.re - num2.re, num1.im - num2.im);
}

module.exports = subtract;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/core/static/tan.js":
/*!***************************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/core/static/tan.js ***!
  \***************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the tangent of a Complex Number.
 * The domain of this function is C / { (k + 0.5)π : k is any integer }.<br><br>
 * 
 * If the argument is out of its domain, it returns Complex.NaN.
 * @memberof Complex
 * @static
 * @param {Complex} num - Any Complex Number which is not in the form of (k + 0.5)π
 * @returns {Complex} The result of tangent function
 */
function tan(num) {
  return this.divide(this.sin(num), this.cos(num));
}

module.exports = tan;

/***/ }),

/***/ "./node_modules/@rayyamhk/complex/lib/index.js":
/*!*****************************************************!*\
  !*** ./node_modules/@rayyamhk/complex/lib/index.js ***!
  \*****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

/**
 * Creates a new Complex Number.
 * @namespace Complex
 * @class
 * @param {number} arg1 - The real part of the Complex Number
 * @param {number} arg2 - The imaginary part of the Complex Number
 */
function Complex(arg1, arg2) {
  var type1 = _typeof(arg1);

  var type2 = _typeof(arg2);

  if (type1 === 'number' && type2 === 'undefined') {
    if (Number.isNaN(arg1) || !Number.isFinite(arg1)) {
      this.re = NaN;
      this.im = NaN;
      return this;
    }

    this.re = arg1;
    this.im = 0;
    return this;
  }

  if (type1 === 'number' && type2 === 'number') {
    if (Number.isNaN(arg1) || Number.isNaN(arg2) || !Number.isFinite(arg1) || !Number.isFinite(arg2)) {
      this.re = NaN;
      this.im = NaN;
      return this;
    }

    this.re = arg1;
    this.im = arg2;
    return this;
  }

  this.re = NaN;
  this.im = NaN;
  return this;
}

module.exports = Complex;
Complex.prototype.getReal = __webpack_require__(/*! ./core/instance/getReal */ "./node_modules/@rayyamhk/complex/lib/core/instance/getReal.js");
Complex.prototype.getImaginary = __webpack_require__(/*! ./core/instance/getImaginary */ "./node_modules/@rayyamhk/complex/lib/core/instance/getImaginary.js");
Complex.prototype.getModulus = __webpack_require__(/*! ./core/instance/getModulus */ "./node_modules/@rayyamhk/complex/lib/core/instance/getModulus.js");
Complex.prototype.getArgument = __webpack_require__(/*! ./core/instance/getArgument */ "./node_modules/@rayyamhk/complex/lib/core/instance/getArgument.js");
Complex.prototype.toString = __webpack_require__(/*! ./core/instance/toString */ "./node_modules/@rayyamhk/complex/lib/core/instance/toString.js");
Complex.isNaN = __webpack_require__(/*! ./core/static/isNaN */ "./node_modules/@rayyamhk/complex/lib/core/static/isNaN.js");
Complex.isEqual = __webpack_require__(/*! ./core/static/isEqual */ "./node_modules/@rayyamhk/complex/lib/core/static/isEqual.js");
Complex.conjugate = __webpack_require__(/*! ./core/static/conjugate */ "./node_modules/@rayyamhk/complex/lib/core/static/conjugate.js");
Complex.inverse = __webpack_require__(/*! ./core/static/inverse */ "./node_modules/@rayyamhk/complex/lib/core/static/inverse.js");
Complex.add = __webpack_require__(/*! ./core/static/add */ "./node_modules/@rayyamhk/complex/lib/core/static/add.js");
Complex.subtract = __webpack_require__(/*! ./core/static/subtract */ "./node_modules/@rayyamhk/complex/lib/core/static/subtract.js");
Complex.multiply = __webpack_require__(/*! ./core/static/multiply */ "./node_modules/@rayyamhk/complex/lib/core/static/multiply.js");
Complex.divide = __webpack_require__(/*! ./core/static/divide */ "./node_modules/@rayyamhk/complex/lib/core/static/divide.js");
Complex.exp = __webpack_require__(/*! ./core/static/exp */ "./node_modules/@rayyamhk/complex/lib/core/static/exp.js");
Complex.log = __webpack_require__(/*! ./core/static/log */ "./node_modules/@rayyamhk/complex/lib/core/static/log.js");
Complex.pow = __webpack_require__(/*! ./core/static/pow */ "./node_modules/@rayyamhk/complex/lib/core/static/pow.js");
Complex.sin = __webpack_require__(/*! ./core/static/sin */ "./node_modules/@rayyamhk/complex/lib/core/static/sin.js");
Complex.cos = __webpack_require__(/*! ./core/static/cos */ "./node_modules/@rayyamhk/complex/lib/core/static/cos.js");
Complex.tan = __webpack_require__(/*! ./core/static/tan */ "./node_modules/@rayyamhk/complex/lib/core/static/tan.js");
Complex.csc = __webpack_require__(/*! ./core/static/csc */ "./node_modules/@rayyamhk/complex/lib/core/static/csc.js");
Complex.sec = __webpack_require__(/*! ./core/static/sec */ "./node_modules/@rayyamhk/complex/lib/core/static/sec.js");
Complex.cot = __webpack_require__(/*! ./core/static/cot */ "./node_modules/@rayyamhk/complex/lib/core/static/cot.js");
Complex.asin = __webpack_require__(/*! ./core/static/asin */ "./node_modules/@rayyamhk/complex/lib/core/static/asin.js");
Complex.acos = __webpack_require__(/*! ./core/static/acos */ "./node_modules/@rayyamhk/complex/lib/core/static/acos.js");
Complex.atan = __webpack_require__(/*! ./core/static/atan */ "./node_modules/@rayyamhk/complex/lib/core/static/atan.js");
Complex.acsc = __webpack_require__(/*! ./core/static/acsc */ "./node_modules/@rayyamhk/complex/lib/core/static/acsc.js");
Complex.asec = __webpack_require__(/*! ./core/static/asec */ "./node_modules/@rayyamhk/complex/lib/core/static/asec.js");
Complex.acot = __webpack_require__(/*! ./core/static/acot */ "./node_modules/@rayyamhk/complex/lib/core/static/acot.js");
/**
 * It represents NaN in this library. It is equivalent to new Complex(NaN).<br><br>
 * 
 * It is important to know that this library does not introduce the concept of Complex Infinity,
 * all Infinity in this library are represented by Complex.NaN.
 * @static
 */

Complex.NaN = new Complex(NaN);
/** @static */

Complex.ONE = new Complex(1);
/** @static */

Complex.ZERO = new Complex(0);
/** @static */

Complex.PI = new Complex(Math.PI);
/** @static */

Complex.E = new Complex(Math.E);
/**
 * It represents the value of 5e-16, which is the smallest number considered as non-zero in this library.
 * In the other words, any number less than Complex.EPSILON is considered as 0.<br><br>
 * 
 * Note that Complex.EPSILON is number instead of instance of Complex.
 * @static
 */

Complex.EPSILON = 1 / (Math.pow(10, 15) * 2);

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/Error.js":
/*!****************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/Error.js ***!
  \****************************************************/
/***/ ((module) => {

"use strict";


module.exports = {
  INVALID_ARRAY: 'Invalid argument: Received a non-array argument',
  INVALID_MATRIX: 'Invalid argument: Received an invalid matrix',
  INVALID_SQUARE_MATRIX: 'Invalid argument: Received a non-square matrix',
  INVALID_UPPER_TRIANGULAR_MATRIX: 'Invalid argument: Received a non upper-triangular matrix',
  INVALID_LOWER_TRIANGULAR_MATRIX: 'Invalid argument: Received a non lower-triangular matrix',
  INVALID_EXPONENT: 'Invalid argument: Expected a non-negative integer exponent',
  INVALID_ROW_COL: 'Invalid argument: Expected non-negative integer row and column',
  INVALID_ROW: 'Invalid argument: Expected non-negative integer row',
  INVALID_COLUMN: 'Invalid argument: Expected non-negative integer column',
  INVALID_ROWS_EXPRESSION: 'Invalid argument: Received invalid rows expression',
  INVALID_COLUMNS_EXPRESSION: 'Invalid argument: Received invalid columns expression',
  INVALID_P_NORM: 'Invalid argument: Received invalid p-norm',
  OVERFLOW_INDEX: 'Invalid argument: Matrix index overflow',
  OVERFLOW_COLUMN: 'Invalid argument: Column index overflow',
  OVERFLOW_ROW: 'Invalid argument: Row index overflow',
  NO_UNIQUE_SOLUTION: 'Arithmetic Exception: The system has no unique solution',
  SIZE_INCOMPATIBLE: 'Invalid argument: Matrix size-incompatible',
  SINGULAR_MATRIX: 'Arithmetic Exception: The matrix is not invertible',
  EXPECTED_STRING_NUMBER_AT_POS_1_2: 'Invalid argument: Expected a string or a number at arguments[1] and arguments[2]',
  EXPECTED_ARRAY_OF_NUMBERS_OR_MATRICES: 'Invalid argument: Expected either an array of numbers or an array of square matrices'
};

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/decompositions/LU.js":
/*!*********************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/decompositions/LU.js ***!
  \*********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX;
/**
 * Calculates the LUP decomposition of the Matrix,
 * where L is lower triangular matrix which diagonal entries are always 1,
 * U is upper triangular matrix, and P is permutation matrix.<br><br>
 * 
 * It is implemented using Gaussian Elimination with Partial Pivoting in order to
 * reduce the error caused by floating-point arithmetic.<br><br>
 * 
 * Note that if optimized is true, P is a Permutation Array and both L and U are merged
 * into one matrix in order to improve performance.
 * @memberof Matrix
 * @static
 * @param {Matrix} A - Any matrix
 * @param {boolean} [optimized=false] - Returns [P, LU] if it is true, [P, L, U] if it is false
 * @returns {Matrix[]} The LUP decomposition of Matrix
 */


function LU(A) {
  var optimized = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

  if (!(A instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  var _A$size = A.size(),
      _A$size2 = _slicedToArray(_A$size, 2),
      row = _A$size2[0],
      col = _A$size2[1];

  var size = Math.min(row, col);
  var EPSILON = 1 / (Math.pow(10, A._digit) * 2);
  var permutation = initPermutation(row);

  var copy = this.clone(A)._matrix;

  for (var i = 0; i < row - 1; i++) {
    var currentCol = Math.min(i, col); // apply Partial Pivoting

    PartialPivoting(copy, permutation, currentCol, row, col);
    var ith = permutation[i];
    var pivot = copy[ith][currentCol];

    if (Math.abs(pivot) < EPSILON) {
      continue;
    }

    for (var j = i + 1; j < row; j++) {
      var jth = permutation[j];
      var entry = copy[jth][currentCol];

      if (Math.abs(entry) >= EPSILON) {
        var factor = entry / pivot;

        for (var k = currentCol; k < col; k++) {
          copy[jth][k] -= factor * copy[ith][k];
        }

        copy[jth][currentCol] = factor;
      }
    }
  }

  var result = new Array(row);

  for (var _i2 = 0; _i2 < row; _i2++) {
    result[_i2] = copy[permutation[_i2]];
  }

  if (optimized) {
    return [permutation, new this(result)];
  }

  var P = this.generate(row, row, function (i, j) {
    var idx = permutation[i];

    if (j === idx) {
      return 1;
    }

    return 0;
  });
  var L = this.generate(row, size, function (i, j) {
    if (i === j) {
      return 1;
    }

    if (i < j) {
      return 0;
    }

    return result[i][j];
  });
  var U = this.generate(size, col, function (i, j) {
    if (i > j) {
      return 0;
    }

    return result[i][j];
  });
  return [P, L, U];
}

;

function initPermutation(size) {
  var permutation = new Array(size);

  for (var i = 0; i < size; i++) {
    permutation[i] = i;
  }

  return permutation;
}

function PartialPivoting(matrix, permutation, pos, row, col) {
  var currentCol = Math.min(pos, col);
  var maxIdx = pos;
  var max = Math.abs(matrix[permutation[pos]][currentCol]);

  for (var i = pos + 1; i < row; i++) {
    var value = Math.abs(matrix[permutation[i]][currentCol]);

    if (value > max) {
      maxIdx = i;
      max = value;
    }
  }

  var t = permutation[pos];
  permutation[pos] = permutation[maxIdx];
  permutation[maxIdx] = t;
}

module.exports = LU;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/decompositions/QR.js":
/*!*********************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/decompositions/QR.js ***!
  \*********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX;
/**
 * Calculates the QR decomposition of the Matrix
 * where Q is orthogonal matrix, R is upper triangular matrix.<br><br>
 * 
 * The algorithm is implemented using Householder Transform instead of Gram–Schmidt process
 * because the Householder Transform is more numerically stable.
 * @memberof Matrix
 * @static
 * @param {Matrix} A - Any matrix
 * @returns {Matrix[]} The QR decomposition of matrix in the form of [Q, R]
 */


function QR(A) {
  if (!(A instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  var _A$size = A.size(),
      _A$size2 = _slicedToArray(_A$size, 2),
      row = _A$size2[0],
      col = _A$size2[1];

  var size = Math.min(row, col);
  var EPSILON = 1 / (Math.pow(10, A._digit) * 2);

  var matrixR = this.clone(A)._matrix;

  var matrixQ = this.identity(row)._matrix;

  for (var j = 0; j < size; j++) {
    // if all entries below main diagonal are considered as zero, skip this round
    var skip = true;

    for (var i = j + 1; i < row; i++) {
      if (Math.abs(matrixR[i][j]) >= EPSILON) {
        skip = false;
        break;
      }
    }

    if (!skip) {
      // Apply Householder transform
      var norm = 0;

      for (var _i2 = j; _i2 < row; _i2++) {
        norm += Math.pow(matrixR[_i2][j], 2);
      }

      norm = Math.sqrt(norm); // reduce floating point arithmatic error

      var s = -1;

      if (matrixR[j][j] < 0) {
        s = 1;
      }

      var u1 = matrixR[j][j] - s * norm;
      var w = new Array(row - j);

      for (var _i3 = 0; _i3 < row - j; _i3++) {
        w[_i3] = matrixR[_i3 + j][j] / u1;
      }

      w[0] = 1;
      var tau = -1 * s * u1 / norm;
      var subR = new Array(row - j);

      for (var _i4 = 0; _i4 < row - j; _i4++) {
        var newRow = new Array(col);

        for (var k = 0; k < col; k++) {
          newRow[k] = matrixR[j + _i4][k];
        }

        subR[_i4] = newRow;
      }

      for (var _i5 = j; _i5 < row; _i5++) {
        for (var _k = 0; _k < col; _k++) {
          var summation = 0;

          for (var m = 0; m < row - j; m++) {
            summation += subR[m][_k] * w[m];
          }

          matrixR[_i5][_k] = subR[_i5 - j][_k] - tau * w[_i5 - j] * summation;
        }
      }

      var subQ = new Array(row);

      for (var _i6 = 0; _i6 < row; _i6++) {
        var _newRow = new Array(row - j);

        for (var _k2 = 0; _k2 < row - j; _k2++) {
          _newRow[_k2] = matrixQ[_i6][j + _k2];
        }

        subQ[_i6] = _newRow;
      }

      for (var _i7 = 0; _i7 < row; _i7++) {
        for (var _k3 = j; _k3 < row; _k3++) {
          var _summation = 0;

          for (var _m = 0; _m < row - j; _m++) {
            _summation += subQ[_i7][_m] * w[_m];
          }

          matrixQ[_i7][_k3] = subQ[_i7][_k3 - j] - tau * w[_k3 - j] * _summation;
        }
      }
    }
  }

  for (var _i8 = 0; _i8 < row; _i8++) {
    for (var _j = 0; _j < col; _j++) {
      if (_i8 > _j) {
        matrixR[_i8][_j] = 0;
      }
    }
  }

  return [new this(matrixQ), new this(matrixR)];
}

;
module.exports = QR;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/linear-equations/backward.js":
/*!*****************************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/linear-equations/backward.js ***!
  \*****************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var empty = __webpack_require__(/*! ../../util/empty */ "./node_modules/@rayyamhk/matrix/lib/util/empty.js");

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX,
    INVALID_UPPER_TRIANGULAR_MATRIX = _require.INVALID_UPPER_TRIANGULAR_MATRIX,
    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX,
    SIZE_INCOMPATIBLE = _require.SIZE_INCOMPATIBLE,
    NO_UNIQUE_SOLUTION = _require.NO_UNIQUE_SOLUTION;
/**
* Solve system of linear equations Ux = y using backward substitution,
* where U is an upper triangular matrix.
* If there is no unique solutions, an error is thrown.
* @memberof Matrix
* @static
* @param {Matrix} U - Any n x n upper triangular Matrix
* @param {Matrix} y - Any n x 1 Matrix
* @returns {Matrix} n x 1 Matrix which is the solution of Ux = y
*/


function backward(U, y) {
  if (!(U instanceof this) || !(y instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  if (!U.isUpperTriangular()) {
    throw new Error(INVALID_UPPER_TRIANGULAR_MATRIX);
  }

  if (!U.isSquare()) {
    throw new Error(INVALID_SQUARE_MATRIX);
  }

  var size = U.size()[0];

  var _y$size = y.size(),
      _y$size2 = _slicedToArray(_y$size, 2),
      yrow = _y$size2[0],
      ycol = _y$size2[1];

  var matrixU = U._matrix;
  var matrixY = y._matrix;

  if (yrow !== size || ycol !== 1) {
    throw new Error(SIZE_INCOMPATIBLE);
  }

  var EPSILON = 1 / (Math.pow(10, U._digit) * 2);

  for (var i = 0; i < size; i++) {
    if (Math.abs(matrixU[i][i]) < EPSILON) {
      throw new Error(NO_UNIQUE_SOLUTION);
    }
  }

  var coefficients = empty(size, 1);

  for (var _i2 = size - 1; _i2 >= 0; _i2--) {
    var summation = 0;

    for (var j = _i2 + 1; j < size; j++) {
      summation += coefficients[j][0] * matrixU[_i2][j];
    }

    coefficients[_i2][0] = (matrixY[_i2][0] - summation) / matrixU[_i2][_i2];
  }

  return new this(coefficients);
}

;
module.exports = backward;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/linear-equations/forward.js":
/*!****************************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/linear-equations/forward.js ***!
  \****************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var empty = __webpack_require__(/*! ../../util/empty */ "./node_modules/@rayyamhk/matrix/lib/util/empty.js");

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX,
    INVALID_LOWER_TRIANGULAR_MATRIX = _require.INVALID_LOWER_TRIANGULAR_MATRIX,
    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX,
    SIZE_INCOMPATIBLE = _require.SIZE_INCOMPATIBLE,
    NO_UNIQUE_SOLUTION = _require.NO_UNIQUE_SOLUTION;
/**
 * Solve system of linear equations Lx = y using forward substitution,
 * where L is a lower triangular matrix.
 * If there is no unique solutions, an error is thrown.
 * @memberof Matrix
 * @static
 * @param {Matrix} L - Any n x n lower triangular Matrix
 * @param {Matrix} y - Any n x 1 Matrix
 * @returns {Matrix} n x 1 Matrix which is the solution of Lx = y
 */


function forward(L, y) {
  if (!(L instanceof this) || !(y instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  if (!L.isLowerTriangular()) {
    throw new Error(INVALID_LOWER_TRIANGULAR_MATRIX);
  }

  if (!L.isSquare()) {
    throw new Error(INVALID_SQUARE_MATRIX);
  }

  var size = L.size()[0];

  var _y$size = y.size(),
      _y$size2 = _slicedToArray(_y$size, 2),
      yrow = _y$size2[0],
      ycol = _y$size2[1];

  var matrixL = L._matrix;
  var matrixY = y._matrix;

  if (size !== yrow || ycol !== 1) {
    throw new Error(SIZE_INCOMPATIBLE);
  }

  var EPSILON = 1 / (Math.pow(10, L._digit) * 2);

  for (var i = 0; i < size; i++) {
    if (Math.abs(matrixL[i][i]) < EPSILON) {
      throw new Error(NO_UNIQUE_SOLUTION);
    }
  }

  var coefficients = empty(size, 1);

  for (var _i2 = 0; _i2 < size; _i2++) {
    var summation = 0;

    for (var j = 0; j < _i2; j++) {
      summation += coefficients[j][0] * matrixL[_i2][j];
    }

    coefficients[_i2][0] = (matrixY[_i2][0] - summation) / matrixL[_i2][_i2];
  }

  return new this(coefficients);
}

;
module.exports = forward;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/linear-equations/solve.js":
/*!**************************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/linear-equations/solve.js ***!
  \**************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX,
    NO_UNIQUE_SOLUTION = _require.NO_UNIQUE_SOLUTION,
    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX,
    SIZE_INCOMPATIBLE = _require.SIZE_INCOMPATIBLE;
/**
 * Solve system of linear equations Ax = y using LU decomposition.
 * If there is no unique solutions, an error is thrown.
 * @memberof Matrix
 * @static
 * @param {Matrix} L - Any n x n square Matrix
 * @param {Matrix} y - Any n x 1 Matrix
 * @returns {Matrix} n x 1 Matrix which is the solution of Ax = y
 */


function solve(A, b) {
  if (!(A instanceof this) || !(b instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  if (!A.isSquare()) {
    throw new Error(INVALID_SQUARE_MATRIX);
  }

  var _A$size = A.size(),
      _A$size2 = _slicedToArray(_A$size, 2),
      aRow = _A$size2[0],
      aCol = _A$size2[1];

  var _b$size = b.size(),
      _b$size2 = _slicedToArray(_b$size, 2),
      bRow = _b$size2[0],
      bCol = _b$size2[1];

  if (aCol !== bRow || bCol !== 1) {
    throw new Error(SIZE_INCOMPATIBLE);
  }

  var EPSILON = 1 / (Math.pow(10, A._digit) * 2);

  var _this$LU = this.LU(A, true),
      _this$LU2 = _slicedToArray(_this$LU, 2),
      P = _this$LU2[0],
      LU = _this$LU2[1];

  var matrixLU = LU._matrix;
  var matrixB = b._matrix;

  for (var i = aRow - 1; i >= 0; i--) {
    if (Math.abs(matrixLU[i][i]) < EPSILON) {
      throw new Error(NO_UNIQUE_SOLUTION);
    }
  }

  var clonedVector = new Array(bRow);
  var coefficients = new Array(bRow);

  for (var _i2 = 0; _i2 < bRow; _i2++) {
    // eslint-disable-next-line prefer-destructuring
    clonedVector[_i2] = matrixB[P[_i2]][0];
  }

  for (var _i3 = 0; _i3 < aRow; _i3++) {
    var summation = 0;

    for (var j = 0; j < _i3; j++) {
      summation += coefficients[j] * matrixLU[_i3][j];
    }

    coefficients[_i3] = clonedVector[_i3] - summation;
  }

  for (var _i4 = aRow - 1; _i4 >= 0; _i4--) {
    var _summation = 0;

    for (var _j = _i4 + 1; _j < aRow; _j++) {
      _summation += matrixLU[_i4][_j] * clonedVector[_j];
    }

    clonedVector[_i4] = (coefficients[_i4] - _summation) / matrixLU[_i4][_i4];
  }

  for (var _i5 = 0; _i5 < bRow; _i5++) {
    coefficients[_i5] = [clonedVector[_i5]];
  }

  return new this(coefficients);
}

;
module.exports = solve;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/operations/add.js":
/*!******************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/operations/add.js ***!
  \******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX,
    SIZE_INCOMPATIBLE = _require.SIZE_INCOMPATIBLE;
/**
 * Calculates the sum of two Matrices.
 * @memberof Matrix
 * @static
 * @param {Matrix} A - Any Matrix
 * @param {Matrix} B - Any Matrix that has same size with A
 * @returns {Matrix} The sum of two Matrices
 */


function add(A, B) {
  if (!(A instanceof this) || !(B instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  var _A$size = A.size(),
      _A$size2 = _slicedToArray(_A$size, 2),
      row = _A$size2[0],
      col = _A$size2[1];

  var _B$size = B.size(),
      _B$size2 = _slicedToArray(_B$size, 2),
      row2 = _B$size2[0],
      col2 = _B$size2[1];

  if (row !== row2 || col !== col2) {
    throw new Error(SIZE_INCOMPATIBLE);
  }

  var matrix1 = A._matrix;
  var matrix2 = B._matrix;
  return this.generate(row, col, function (i, j) {
    return matrix1[i][j] + matrix2[i][j];
  });
}

;
module.exports = add;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/operations/inverse.js":
/*!**********************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/operations/inverse.js ***!
  \**********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX,
    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX,
    SINGULAR_MATRIX = _require.SINGULAR_MATRIX;

var Matrix = __webpack_require__(/*! ../.. */ "./node_modules/@rayyamhk/matrix/lib/index.js");
/**
 * Find the inverse of non-singular matrix using Elementary Row Operations.
 * If the matrix is singular, an error is thrown.
 * @memberof Matrix
 * @static
 * @param {Matrix} A - Any square Matrix
 * @returns {Matrix} The inverse of A
 */


function inverse(A) {
  if (!(A instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  if (!A.isSquare()) {
    throw new Error(INVALID_SQUARE_MATRIX);
  }

  var size = A.size()[0];

  if (size === 0) {
    // inverse of 0x0 matrix is itself
    return new Matrix([]);
  }

  var EPSILON = 1 / (Math.pow(10, A._digit) * 2);

  var inv = this.identity(size)._matrix;

  var clone = this.clone(A)._matrix;

  var permutation = initPermutation(size); // iterate each column

  for (var j = 0; j < size; j++) {
    var pivotIdx = j;
    var pivot = clone[permutation[j]][j];

    while (Math.abs(pivot) < EPSILON && pivotIdx < size - 1) {
      pivotIdx++;
      pivot = clone[permutation[pivotIdx]][j];
    }

    if (Math.abs(pivot) < EPSILON) {
      throw new Error(SINGULAR_MATRIX);
    }

    if (j !== pivotIdx) {
      var temp = permutation[j];
      permutation[j] = permutation[pivotIdx];
      permutation[pivotIdx] = temp;
    }

    var pivotRow = permutation[j]; // the pivot is guaranteed to be non-zero

    for (var i = 0; i < size; i++) {
      var ith = permutation[i];

      if (i === j) {
        for (var k = 0; k < size; k++) {
          if (k === j) {
            clone[ith][k] = 1;
          }

          if (k > j) {
            clone[ith][k] /= pivot;
          }

          inv[ith][k] /= pivot;
        }

        pivot = 1;
      }

      if (i !== j && Math.abs(clone[ith][j]) >= EPSILON) {
        var factor = clone[ith][j] / pivot;

        for (var _k = 0; _k < size; _k++) {
          if (_k === j) {
            clone[ith][_k] = 0;
          }

          if (_k > j) {
            clone[ith][_k] -= factor * clone[pivotRow][_k];
          }

          inv[ith][_k] -= factor * inv[pivotRow][_k];
        }
      }
    }
  }

  for (var _i = 0; _i < size; _i++) {
    clone[_i] = inv[permutation[_i]];
  }

  return new this(clone);
}

;

function initPermutation(size) {
  var permutation = new Array(size);

  for (var i = 0; i < size; i++) {
    permutation[i] = i;
  }

  return permutation;
}

module.exports = inverse;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/operations/multiply.js":
/*!***********************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/operations/multiply.js ***!
  \***********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var empty = __webpack_require__(/*! ../../util/empty */ "./node_modules/@rayyamhk/matrix/lib/util/empty.js");

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX,
    SIZE_INCOMPATIBLE = _require.SIZE_INCOMPATIBLE;
/**
 * Calculates the product of two Matrices.
 * @memberof Matrix
 * @static
 * @param {Matrix} A - Any Matrix
 * @param {Matrix} B - Any Matrix that is size-compatible with A
 * @returns {Matrix} The product of two Matrices
 */


function multiply(A, B) {
  if (!(A instanceof this) || !(B instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  var _A$size = A.size(),
      _A$size2 = _slicedToArray(_A$size, 2),
      Arow = _A$size2[0],
      Acol = _A$size2[1];

  var _B$size = B.size(),
      _B$size2 = _slicedToArray(_B$size, 2),
      Brow = _B$size2[0],
      Bcol = _B$size2[1];

  if (Acol !== Brow) {
    throw new Error(SIZE_INCOMPATIBLE);
  }

  var matrixA = A._matrix;
  var matrixB = B._matrix;
  var result = empty(Arow, Bcol);

  for (var i = 0; i < Arow; i++) {
    for (var j = 0; j < Bcol; j++) {
      result[i][j] = 0;

      for (var k = 0; k < Brow; k++) {
        result[i][j] += matrixA[i][k] * matrixB[k][j];
      }
    }
  }

  return new this(result);
}

;
module.exports = multiply;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/operations/pow.js":
/*!******************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/operations/pow.js ***!
  \******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX,
    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX,
    INVALID_EXPONENT = _require.INVALID_EXPONENT;
/**
 * Calculates the power of any square matrix.
 * The algorithm is implemented recursively.
 * @memberof Matrix
 * @static
 * @param {Matrix} A - Any square Matrix
 * @param {number} exponent - Any Non-negative integer
 * @returns {Matrix} The power of A
 */


function pow(A, exponent) {
  if (!(A instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  if (!A.isSquare()) {
    throw new Error(INVALID_SQUARE_MATRIX);
  }

  if (!Number.isInteger(exponent) || exponent < 0) {
    throw new Error(INVALID_EXPONENT);
  }

  var size = A.size()[0];

  if (exponent === 0) {
    return this.identity(size);
  }

  if (exponent === 1) {
    return this.clone(A);
  }

  if (exponent % 2 === 0) {
    var _temp = this.pow(A, exponent / 2);

    return this.multiply(_temp, _temp);
  }

  var temp = this.pow(A, (exponent - 1) / 2);
  return this.multiply(this.multiply(temp, temp), A);
}

;
module.exports = pow;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/operations/subtract.js":
/*!***********************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/operations/subtract.js ***!
  \***********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    SIZE_INCOMPATIBLE = _require.SIZE_INCOMPATIBLE,
    INVALID_MATRIX = _require.INVALID_MATRIX;
/**
 * Calculates the difference of two Matrices.
 * @memberof Matrix
 * @static
 * @param {Matrix} A - Any Matrix
 * @param {Matrix} B - Any Matrix that has same size with A
 * @returns {Matrix} The difference of two Matrices
 */


module.exports = function subtract(A, B) {
  if (!(A instanceof this) || !(B instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  var _A$size = A.size(),
      _A$size2 = _slicedToArray(_A$size, 2),
      row = _A$size2[0],
      col = _A$size2[1];

  var _B$size = B.size(),
      _B$size2 = _slicedToArray(_B$size, 2),
      row2 = _B$size2[0],
      col2 = _B$size2[1];

  if (row !== row2 || col !== col2) {
    throw new Error(SIZE_INCOMPATIBLE);
  }

  var matrix1 = A._matrix;
  var matrix2 = B._matrix;
  return this.generate(row, col, function (i, j) {
    return matrix1[i][j] - matrix2[i][j];
  });
};

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/operations/transpose.js":
/*!************************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/operations/transpose.js ***!
  \************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX;
/**
 * Find the transpose of a matrix.
 * @memberof Matrix
 * @static
 * @param { Matrix } A - Any Matrix
 * @returns { Matrix } Returns transpose of A
 */


function transpose(A) {
  if (!(A instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  var _A$size = A.size(),
      _A$size2 = _slicedToArray(_A$size, 2),
      row = _A$size2[0],
      col = _A$size2[1];

  var matrix = A._matrix;
  return this.generate(col, row, function (i, j) {
    return matrix[j][i];
  });
}

;
module.exports = transpose;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/properties/cond.js":
/*!*******************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/properties/cond.js ***!
  \*******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var Matrix = __webpack_require__(/*! ../.. */ "./node_modules/@rayyamhk/matrix/lib/index.js");

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_P_NORM = _require.INVALID_P_NORM,
    SINGULAR_MATRIX = _require.SINGULAR_MATRIX,
    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX;
/**
 * Calculations the condition number of square Matrix
 * with respect to the choice of Matrix norm. 
 * If the Matrix is singular, returns Infinity.<br><br>
 * The condition number is not cached.
 * @memberof Matrix
 * @instance
 * @param {(1|2|Infinity|'F')} p - Type of Matrix norm
 * @returns {number} The condition number of Matrix
 */


function cond() {
  var p = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 2;

  if (p !== 1 && p !== 2 && p !== Infinity && p !== 'F') {
    throw new Error(INVALID_P_NORM);
  }

  if (!this.isSquare()) {
    throw new Error(INVALID_SQUARE_MATRIX);
  }

  try {
    var inverse = Matrix.inverse(this);
    return inverse.norm(p) * this.norm(p);
  } catch (error) {
    if (error.message === SINGULAR_MATRIX) {
      return Infinity;
    }

    throw error;
  }
}

;
module.exports = cond;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/properties/det.js":
/*!******************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/properties/det.js ***!
  \******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

/* eslint-disable prefer-destructuring */
var Matrix = __webpack_require__(/*! ../.. */ "./node_modules/@rayyamhk/matrix/lib/index.js");

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX;
/**
 * Calculates the determinant of square Matrix.
 * If the Matrix size is larger than 3, it calculates the determinant using
 * LU decomposition, otherwise, using Leibniz Formula.<br><br>
 * The determinant is cached.
 * @memberof Matrix
 * @instance
 * @returns {number} Returns the determinant of square matrirx
 */


function det() {
  if (!this.isSquare()) {
    throw new Error(INVALID_SQUARE_MATRIX);
  }

  if (this._det !== undefined) {
    return this._det;
  }

  var matrix = this._matrix;
  var size = matrix.length;

  if (size === 0) {
    this._det = 1;
    return 1; // the determinant of 0x0 matrix must be 1
  }

  if (size === 1) {
    this._det = matrix[0][0];
    return this._det;
  }

  if (size === 2) {
    this._det = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    return this._det;
  }

  if (size === 3) {
    this._det = matrix[0][0] * matrix[1][1] * matrix[2][2] + matrix[0][1] * matrix[1][2] * matrix[2][0] + matrix[0][2] * matrix[1][0] * matrix[2][1] - matrix[0][2] * matrix[1][1] * matrix[2][0] - matrix[0][1] * matrix[1][0] * matrix[2][2] - matrix[0][0] * matrix[1][2] * matrix[2][1];
    return this._det;
  }

  var _Matrix$LU = Matrix.LU(this, true),
      _Matrix$LU2 = _slicedToArray(_Matrix$LU, 2),
      P = _Matrix$LU2[0],
      LU = _Matrix$LU2[1];

  var matrixLU = LU._matrix; // count whether the number of permutations <swap> is odd or even
  // O(n^2)

  var swap = 0;

  for (var i = 0; i < size; i++) {
    if (P[i] === i) {
      continue;
    }

    while (P[i] !== i) {
      var target = P[i];
      P[i] = P[target];
      P[target] = target;
      swap++;
    }
  }

  var result = 1;

  for (var _i2 = 0; _i2 < size; _i2++) {
    result *= matrixLU[_i2][_i2];
  }

  if (swap % 2 === 1) {
    this._det = result * -1;
    return this._det;
  }

  this._det = result;
  return result;
}

;
module.exports = det;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/properties/eigenvalues.js":
/*!**************************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/properties/eigenvalues.js ***!
  \**************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

/* eslint-disable no-param-reassign */
// reference: https://people.inf.ethz.ch/arbenz/ewp/Lnotes/chapter4.pdf
var Complex = __webpack_require__(/*! @rayyamhk/complex */ "./node_modules/@rayyamhk/complex/lib/index.js");

var Matrix = __webpack_require__(/*! ../.. */ "./node_modules/@rayyamhk/matrix/lib/index.js");

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX;
/**
 * Calculates the eigenvalues of any square Matrix using QR Algorithm.<br><br>
 * 
 * The eigenvalues can be either real number or complex number.
 * Note that all eigenvalues are instance of Complex,
 * for more details please visit [Complex.js]{@link https://github.com/rayyamhk/Complex.js}.<br><br>
 * 
 * The eigenvalues are cached.
 * @memberof Matrix
 * @instance
 * @returns {Complex[]} Array of eigenvalues
 */


function eigenvalues() {
  if (!this.isSquare()) {
    throw new Error(INVALID_SQUARE_MATRIX);
  }

  if (this._eigenvalues !== undefined) {
    return this._eigenvalues;
  }

  var size = this.size()[0];
  var values = [];
  var digit = this._digit;
  var EPSILON = 1 / (Math.pow(10, digit) * 2);

  var clone = Matrix.clone(this)._matrix;

  var isConvergent = true; // flag

  var skip = false; // Transform matrix to Hessenberg matrix

  HouseholderTransform(clone, digit);

  for (var i = size - 1; i > 0; i--) {
    var divergenceCount = 0;
    var prev = void 0; // used to determine convergence
    // if obtains complex eigenvalues pair in previous iteration, skip current round

    if (skip) {
      skip = false;
      continue;
    }

    var shift = clone[size - 1][size - 1]; // eslint-disable-next-line no-constant-condition

    while (true) {
      if (!isConvergent) {
        // if the current eigenvalue is not real
        prev = size2Eigenvalues(clone[i - 1][i - 1], clone[i - 1][i], clone[i][i - 1], clone[i][i]).metric;
      } else {
        // if the current eigenvalue is real
        prev = Math.abs(clone[i][i - 1]);
      } // apply single shift


      for (var j = 0; j < size; j++) {
        clone[j][j] -= shift;
      } // Apply QR Algorithm


      HessenbergQR(clone, digit);

      for (var _j = 0; _j < size; _j++) {
        clone[_j][_j] += shift;
      }

      if (isConvergent && prev < Math.abs(clone[i][i - 1])) {
        divergenceCount++;
      } // if the current eigenvalue is real and the entry is almost ZERO => break;


      if (isConvergent && Math.abs(clone[i][i - 1]) < EPSILON) {
        values[i] = new Complex(clone[i][i]);
        break;
      } // if the current eigenvalues pair is complex, if the difference of the previous eiganvalues and the
      // eigenvalues of submatrix is almost ZERO => break


      var _size2Eigenvalues = size2Eigenvalues(clone[i - 1][i - 1], clone[i - 1][i], clone[i][i - 1], clone[i][i]),
          metric = _size2Eigenvalues.metric,
          eigen1 = _size2Eigenvalues.eigen1,
          eigen2 = _size2Eigenvalues.eigen2;

      if (!isConvergent && Math.abs(prev - metric) < EPSILON) {
        isConvergent = true; // re-initialize

        skip = true;
        var re1 = eigen1.re,
            im1 = eigen1.im;
        var re2 = eigen2.re,
            im2 = eigen2.im;
        values[i] = new Complex(re1, im1);
        values[i - 1] = new Complex(re2, im2);
        break;
      } // if the entry doesn't converge => complex eigenvalues pair


      if (divergenceCount > 3) {
        isConvergent = false;
      }
    }
  }

  if (!skip) {
    values[0] = new Complex(clone[0][0]);
  }

  this._eigenvalues = values;
  return values;
}

;

function HouseholderTransform(A, digit) {
  var size = A.length;
  var EPSILON = 1 / (Math.pow(10, digit) * 2);

  for (var j = 0; j < size - 2; j++) {
    var xNorm = 0;
    var u = new Array(size - j - 1);

    for (var i = j + 1; i < size; i++) {
      var entry = A[i][j];
      xNorm += Math.pow(entry, 2);
      u[i - j - 1] = entry;
    }

    xNorm = Math.sqrt(xNorm);

    if (Math.abs(xNorm) < EPSILON) {
      continue;
    }

    if (u[0] >= 0) {
      u[0] += xNorm;
    } else {
      u[0] -= xNorm;
    } // Make 'u' unit vector


    var uNorm = 0;

    for (var _i = 0; _i < u.length; _i++) {
      uNorm += Math.pow(u[_i], 2);
    }

    uNorm = Math.sqrt(uNorm);

    for (var _i2 = 0; _i2 < u.length; _i2++) {
      u[_i2] /= uNorm;
    } // update the matrix, multiply P from left


    for (var n = j; n < size; n++) {
      // column
      var v = new Array(size - j - 1);

      for (var m = j + 1; m < size; m++) {
        v[m - j - 1] = A[m][n];
      }

      var scaler = 0;

      for (var _m = 0; _m < v.length; _m++) {
        scaler += v[_m] * u[_m];
      }

      scaler *= 2;

      for (var _m2 = j + 1; _m2 < size; _m2++) {
        // row
        if (n === j && _m2 !== j + 1) {
          A[_m2][n] = 0;
        } else {
          A[_m2][n] = v[_m2 - j - 1] - scaler * u[_m2 - j - 1];
        }
      }
    } // update the matrix, multiply P from right


    for (var _m3 = 0; _m3 < size; _m3++) {
      // row
      var _v = new Array(size - j - 1);

      for (var _n = j + 1; _n < size; _n++) {
        _v[_n - j - 1] = A[_m3][_n];
      }

      var _scaler = 0;

      for (var _n2 = 0; _n2 < _v.length; _n2++) {
        _scaler += _v[_n2] * u[_n2];
      }

      _scaler *= 2;

      for (var _n3 = j + 1; _n3 < size; _n3++) {
        // column
        A[_m3][_n3] = _v[_n3 - j - 1] - _scaler * u[_n3 - j - 1];
      }
    }
  }
}

function HessenbergQR(H, digit) {
  var size = H.length;
  var EPSILON = 1 / (Math.pow(10, digit) * 2);
  var sincos = new Array(size - 1);

  for (var i = 0; i < size - 1; i++) {
    var a = H[i][i];
    var c = H[i + 1][i];
    var norm = Math.sqrt(Math.pow(a, 2) + Math.pow(c, 2));

    if (norm < EPSILON) {
      continue;
    }

    var cos = a / norm;
    var sin = c * -1 / norm;
    sincos[i] = [sin, cos];
    var row1 = new Array(size - i);
    var row2 = new Array(size - i);

    for (var j = i; j < size; j++) {
      row1[j - i] = H[i][j];
      row2[j - i] = H[i + 1][j];
    }

    for (var _j2 = i; _j2 < size; _j2++) {
      H[i][_j2] = cos * row1[_j2 - i] + sin * -1 * row2[_j2 - i];

      if (i === _j2) {
        H[i + 1][_j2] = 0;
      } else {
        H[i + 1][_j2] = sin * row1[_j2 - i] + cos * row2[_j2 - i];
      }
    }
  }

  for (var _j3 = 0; _j3 < size - 1; _j3++) {
    if (!sincos[_j3]) {
      continue;
    }

    var _sincos$_j = _slicedToArray(sincos[_j3], 2),
        _sin = _sincos$_j[0],
        _cos = _sincos$_j[1];

    var col1 = new Array(_j3 + 2);
    var col2 = new Array(_j3 + 2);

    for (var _i3 = 0; _i3 <= _j3 + 1; _i3++) {
      col1[_i3] = H[_i3][_j3];
      col2[_i3] = H[_i3][_j3 + 1];
    }

    for (var _i4 = 0; _i4 <= _j3 + 1; _i4++) {
      H[_i4][_j3] = col1[_i4] * _cos - col2[_i4] * _sin;
      H[_i4][_j3 + 1] = col1[_i4] * _sin + col2[_i4] * _cos;
    }
  }
} // find the eigenvalues of 2x2 matrix


function size2Eigenvalues(e11, e12, e21, e22) {
  var b = (e11 + e22) * -1;
  var c = e11 * e22 - e21 * e12;
  var delta = Math.pow(b, 2) - 4 * c;
  var re1;
  var im1;
  var re2;
  var im2;

  if (delta >= 0) {
    im1 = 0;
    im2 = 0;

    if (b >= 0) {
      re1 = (b * -1 - Math.sqrt(delta)) / 2;
    } else {
      re1 = (b * -1 + Math.sqrt(delta)) / 2;
    }

    re2 = c / re1;
  } else {
    re1 = -b / 2;
    re2 = re1;
    im1 = Math.sqrt(delta * -1) / 2;
    im2 = im1 * -1;
  }

  return {
    metric: Math.sqrt(Math.pow(re1, 2) + Math.pow(im1, 2)),
    eigen1: {
      re: re1,
      im: im1
    },
    eigen2: {
      re: re2,
      im: im2
    }
  };
}

module.exports = eigenvalues;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/properties/norm.js":
/*!*******************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/properties/norm.js ***!
  \*******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var Matrix = __webpack_require__(/*! ../.. */ "./node_modules/@rayyamhk/matrix/lib/index.js");

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_P_NORM = _require.INVALID_P_NORM;
/**
 * Calculates the Matrix norm of any Matrix with respect to the choice of norm.<br><br>
 * 
 * 1-norm: Maximum absolute column sum of the Matrix.<br>
 * 2-norm: The largest singular value of Matrix.<br>
 * Infinity-norm: Maximum absolute row sum of the Matrix.<br>
 * Frobenius-norm: Euclidean norm invloving all entries.<br><br>
 * 
 * The norms are not cached.
 * @memberof Matrix
 * @instance
 * @param {(1|2|Infinity|'F')} p - The choice of Matrix norm
 * @returns {number} The norm of the Matrix.
 */


function norm() {
  var p = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 2;

  var _this$size = this.size(),
      _this$size2 = _slicedToArray(_this$size, 2),
      row = _this$size2[0],
      col = _this$size2[1];

  if (p !== 1 && p !== 2 && p !== Infinity && p !== 'F') {
    throw new Error(INVALID_P_NORM);
  }

  var matrix = this._matrix;
  var result = 0;

  if (p === 1) {
    // max of column sum
    for (var j = 0; j < col; j++) {
      var columnSum = 0;

      for (var i = 0; i < row; i++) {
        columnSum += Math.abs(matrix[i][j]);
      }

      if (columnSum > result) {
        result = columnSum;
      }
    }

    return result;
  } // largest singular value


  if (p === 2) {
    var transpose = Matrix.transpose(this);
    var M = Matrix.multiply(transpose, this);
    var eigenvalues = M.eigenvalues();

    for (var _i2 = 0; _i2 < eigenvalues.length; _i2++) {
      var value = eigenvalues[_i2].getModulus();

      if (value > result) {
        result = value;
      }
    }

    return Math.sqrt(result);
  }

  if (p === Infinity) {
    // max of row sum
    for (var _i3 = 0; _i3 < row; _i3++) {
      var rowSum = 0;

      for (var _j = 0; _j < col; _j++) {
        rowSum += Math.abs(matrix[_i3][_j]);
      }

      if (rowSum > result) {
        result = rowSum;
      }
    }

    return result;
  } // F


  for (var _i4 = 0; _i4 < row; _i4++) {
    for (var _j2 = 0; _j2 < col; _j2++) {
      result += Math.pow(matrix[_i4][_j2], 2);
    }
  }

  return Math.sqrt(result);
}

;
module.exports = norm;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/properties/nullity.js":
/*!**********************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/properties/nullity.js ***!
  \**********************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the nullity of any Matrix, which is the dimension
 * of the nullspace.<br><br>
 * 
 * The nullity is cached.
 * @memberof Matrix
 * @instance
 * @returns {number} The nullity of the matrix
 */
function nullity() {
  if (this._nullity !== undefined) {
    return this._nullity;
  }

  var col = this.size()[1];
  var rank = this.rank();
  this._nullity = col - rank;
  return this._nullity;
}

;
module.exports = nullity;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/properties/rank.js":
/*!*******************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/properties/rank.js ***!
  \*******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var Matrix = __webpack_require__(/*! ../.. */ "./node_modules/@rayyamhk/matrix/lib/index.js");
/**
 * Calculates the rank of any Matrix,
 * which is the dimension of the row space.<br><br>
 * 
 * The rank is cached.
 * @memberof Matrix
 * @instance
 * @returns {number} The rank of the Matrix
 */


function rank() {
  if (this._rank !== undefined) {
    return this._rank;
  }

  var EPSILON = 1 / (Math.pow(10, this._digit) * 2);
  var R = Matrix.QR(this)[1];
  var matrixR = R._matrix;

  var _R$size = R.size(),
      _R$size2 = _slicedToArray(_R$size, 2),
      row = _R$size2[0],
      col = _R$size2[1];

  if (row === 0) {
    this._rank = 1;
    return 1;
  }

  var rk = 0;

  for (var i = 0; i < row; i++) {
    for (var j = i; j < col; j++) {
      if (Math.abs(matrixR[i][j]) >= EPSILON) {
        rk++;
        break;
      }
    }
  }

  this._rank = rk;
  return rk;
}

;
module.exports = rank;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/properties/size.js":
/*!*******************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/properties/size.js ***!
  \*******************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Calculates the size of any Matrix,
 * which is in the form of [row, column].<br><br>
 * 
 * The size of Matrix is cached.
 * @memberof Matrix
 * @instance
 * @returns {number[]} The number of rows and columns of a Matrix
 */
function size() {
  if (this._size !== undefined) {
    return this._size;
  }

  var A = this._matrix;

  if (A.length === 0) {
    this._size = [0, 0];
    return this._size;
  }

  this._size = [A.length, A[0].length];
  return this._size;
}

;
module.exports = size;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/properties/trace.js":
/*!********************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/properties/trace.js ***!
  \********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX;
/**
 * Calculates the trace of any square Matrix,
 * which is the sum of all entries on the main diagonal.<br><br>
 * 
 * The trace is cached.
 * @memberof Matrix
 * @instance
 * @returns {number} The trace of the square Matrix.
 */


function trace() {
  var isSquare = this._isSquare !== undefined ? this._isSquare : this.isSquare();

  if (!isSquare) {
    throw new Error(INVALID_SQUARE_MATRIX);
  }

  if (this._trace !== undefined) {
    return this._trace;
  }

  var A = this._matrix;
  var size = A.length;
  var tr = 0;

  for (var i = 0; i < size; i++) {
    tr += A[i][i];
  }

  this._trace = tr;
  return tr;
}

;
module.exports = trace;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/structure/isDiagonal.js":
/*!************************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/structure/isDiagonal.js ***!
  \************************************************************************/
/***/ ((module) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

/**
 * Determines whether a Matrix is diagonal or not.<br><br>
 * 
 * Diagonal Matrix is a Matrix in which the entries outside the main diagonal
 * are all zero. Note that the term diagonal refers to rectangular diagonal.<br><br>
 * 
 * The result is cached.
 * @memberof Matrix
 * @instance
 * @param {number} [digit=8] - Number of significant digits
 * @returns {boolean} Returns rue if the Matrix is diagonal Matrix
 */
function isDiagonal() {
  var digit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._digit;

  if (this._isDiagonal !== undefined) {
    return this._isDiagonal;
  }

  var EPSILON = 1 / (Math.pow(10, digit) * 2);
  var A = this._matrix;

  var _this$size = this.size(),
      _this$size2 = _slicedToArray(_this$size, 2),
      row = _this$size2[0],
      col = _this$size2[1];

  if (row === 0) {
    this._isDiagonal = true;
    return true;
  }

  for (var i = 0; i < row; i++) {
    for (var j = 0; j < col; j++) {
      if (i !== j && Math.abs(A[i][j]) >= EPSILON) {
        this.isDiagonal = false;
        return false;
      }
    }
  }

  this._isDiagonal = true;
  return true;
}

;
module.exports = isDiagonal;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/structure/isLowerTriangular.js":
/*!*******************************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/structure/isLowerTriangular.js ***!
  \*******************************************************************************/
/***/ ((module) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

/**
 * Determines whether a Matrix is lower triangular Matrix or not.<br><br>
 * 
 * Lower triangular Matrix is a Matrix in which all the entries
 * above the main diagonal are zero. Note that it can be applied
 * to any non-square Matrix.<br><br>
 * 
 * The result is cached.
 * @memberof Matrix
 * @instance
 * @param {number} [digit=8] - Number of significant digits
 * @returns {boolean} Returns true if the Matrix is lower triangular
 */
function isLowerTriangular() {
  var digit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._digit;

  if (this._isLowerTriangular !== undefined) {
    return this._isLowerTriangular;
  }

  var EPSILON = 1 / (Math.pow(10, digit) * 2);
  var A = this._matrix;

  var _this$size = this.size(),
      _this$size2 = _slicedToArray(_this$size, 2),
      row = _this$size2[0],
      col = _this$size2[1];

  if (row === 0) {
    // []
    this._isLowerTriangular = true;
    return true;
  }

  for (var i = 0; i < row; i++) {
    for (var j = i + 1; j < col; j++) {
      if (Math.abs(A[i][j]) >= EPSILON) {
        this._isLowerTriangular = false;
        return false;
      }
    }
  }

  this._isLowerTriangular = true;
  return true;
}

;
module.exports = isLowerTriangular;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/structure/isOrthogonal.js":
/*!**************************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/structure/isOrthogonal.js ***!
  \**************************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Determines whether a square Matrix is orthogonal or not.<br><br>
 * 
 * Orthogonal Matrix is a Matrix in which all rows and columns are
 * orthonormal vectors.<br><br>
 * 
 * The result is cached.
 * @memberof Matrix
 * @instance
 * @param {number} [digit=8] - Number of significant digits
 * @returns {boolean} Returns true if the square Matrix is orthogonal
 */
function isOrthogonal() {
  var digit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._digit;

  if (this._isOrthogonal !== undefined) {
    return this._isOrthogonal;
  }

  if (!this.isSquare()) {
    this._isOrthogonal = false;
    return false;
  }

  var A = this._matrix;
  var EPSILON = 1 / (Math.pow(10, digit) * 2);
  var size = A.length;

  for (var i = 0; i < size; i++) {
    for (var j = i; j < size; j++) {
      var entry = 0;

      for (var k = 0; k < size; k++) {
        entry += A[i][k] * A[j][k];
      }

      if (i === j && Math.abs(entry - 1) >= EPSILON) {
        this._isOrthogonal = false;
        return false;
      }

      if (i !== j && Math.abs(entry) >= EPSILON) {
        this._isOrthogonal = false;
        return false;
      }
    }
  }

  this._isOrthogonal = true;
  return true;
}

;
module.exports = isOrthogonal;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/structure/isSkewSymmetric.js":
/*!*****************************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/structure/isSkewSymmetric.js ***!
  \*****************************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Determines whether a square Matrix is skew symmetric or not.<br><br>
 * 
 * Skew symmetric Matrix is a square Matrix whose transpose equals its negative.<br><br>
 * 
 * The result is cached.
 * @memberof Matrix
 * @instance
 * @param {number} [digit=8] - Number of significant digits
 * @returns {boolean} Returns true if the square Matrix is skew symmetric
 */
function isSkewSymmetric() {
  var digit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._digit;

  if (this._isSkewSymmetric !== undefined) {
    return this._isSkewSymmetric;
  }

  if (!this.isSquare()) {
    this._isSkewSymmetric = false;
    return false;
  }

  var A = this._matrix;
  var EPSILON = 1 / (Math.pow(10, digit) * 2);
  var size = A.length;

  if (size === 0) {
    this._isSkewSymmetric = true;
    return true; // []
  }

  for (var i = 0; i < size; i++) {
    for (var j = 0; j < i; j++) {
      if (Math.abs(A[i][j] + A[j][i]) >= EPSILON) {
        this._isSkewSymmetric = false;
        return false;
      }
    }
  }

  this._isSkewSymmetric = true;
  return true;
}

;
module.exports = isSkewSymmetric;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/structure/isSquare.js":
/*!**********************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/structure/isSquare.js ***!
  \**********************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Determines whether a Matrix is square or not.<br><br>
 * 
 * Square Matrix is a Matrix with same number of rows and columns.<br><br>
 * 
 * The result is cached.
 * @memberof Matrix
 * @instance
 * @returns {boolean} Returns true if the Matrix is square
 */
function isSquare() {
  if (this._isSquare !== undefined) {
    return this._isSquare;
  }

  var A = this._matrix;

  if (A.length === 0) {
    // 0x0 matrix
    this._isSquare = true;
    return true;
  }

  this._isSquare = A.length === A[0].length;
  return this._isSquare;
}

;
module.exports = isSquare;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/structure/isSymmetric.js":
/*!*************************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/structure/isSymmetric.js ***!
  \*************************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Determines whether a square Matrix is symmetric or not.<br><br>
 * 
 * Symmetric Matrix is a square Matrix that is equal to its transpose.<br><br>
 * 
 * The result is cached.
 * @memberof Matrix
 * @instance
 * @param {number} [digit=8] - Number of significant digits
 * @returns {boolean} Returns true if the square Matrix is symmetric
 */
function isSymmetric() {
  var digit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._digit;

  if (this._isSymmetric !== undefined) {
    return this._isSymmetric;
  }

  if (!this.isSquare()) {
    return false;
  }

  var A = this._matrix;
  var EPSILON = 1 / (Math.pow(10, digit) * 2);
  var size = A.length;

  for (var i = 0; i < size; i++) {
    for (var j = 0; j <= i; j++) {
      if (Math.abs(A[i][j] - A[j][i]) >= EPSILON) {
        this._isSymmetric = false;
        return false;
      }
    }
  }

  this._isSymmetric = true;
  return true;
}

;
module.exports = isSymmetric;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/structure/isUpperTriangular.js":
/*!*******************************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/structure/isUpperTriangular.js ***!
  \*******************************************************************************/
/***/ ((module) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

/**
 * Determines whether a Matrix is upper triangular Matrix or not.<br><br>
 * 
 * Upper triangular Matrix is a Matrix in which all the entries below the
 * main diagonal are zero. Note that it can be applied to any non-square Matrix.<br><br>
 *  
 * The result is cached.
 * @memberof Matrix
 * @instance
 * @param {number} [digit=8] - Number of significant digits
 * @returns {boolean} Returns true if the Matrix is upper triangular
 */
function isUpperTriangular() {
  var digit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._digit;

  if (this._isUpperTriangular !== undefined) {
    return this._isUpperTriangular;
  }

  var EPSILON = 1 / (Math.pow(10, digit) * 2);
  var A = this._matrix;

  var _this$size = this.size(),
      _this$size2 = _slicedToArray(_this$size, 2),
      row = _this$size2[0],
      col = _this$size2[1];

  if (row === 0) {
    // []
    this._isUpperTriangular = true;
    return true;
  }

  for (var i = 0; i < row; i++) {
    for (var j = 0; j < col; j++) {
      if (i <= j) {
        continue;
      }

      if (Math.abs(A[i][j]) >= EPSILON) {
        this._isUpperTriangular = false;
        return false;
      }
    }
  }

  this._isUpperTriangular = true;
  return true;
}

;
module.exports = isUpperTriangular;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/utils/clone.js":
/*!***************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/utils/clone.js ***!
  \***************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX;
/**
 * Creates a copy of Matrix. Note that it resets the cached data.
 * @memberof Matrix
 * @static
 * @param {Matrix} A - Any Matrix
 * @returns {Matrix} Copy of A
 */


function clone(A) {
  if (!(A instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  var _A$size = A.size(),
      _A$size2 = _slicedToArray(_A$size, 2),
      row = _A$size2[0],
      col = _A$size2[1];

  var matrix = A._matrix;
  return this.generate(row, col, function (i, j) {
    return matrix[i][j];
  });
}

;
module.exports = clone;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/utils/column.js":
/*!****************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/utils/column.js ***!
  \****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_ROW_COL = _require.INVALID_ROW_COL,
    OVERFLOW_COLUMN = _require.OVERFLOW_COLUMN,
    INVALID_MATRIX = _require.INVALID_MATRIX;
/**
 * Gets the column of a Matrix with valid index.
 * @memberof Matrix
 * @static
 * @param {Matrix} A - Any Matrix
 * @param {number} index - Any valid column index
 * @returns {Matrix} Column of A
 */


function column(A, index) {
  if (!(A instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  if (!Number.isInteger(index) || index < 0) {
    throw new Error(INVALID_ROW_COL);
  }

  var _A$size = A.size(),
      _A$size2 = _slicedToArray(_A$size, 2),
      r = _A$size2[0],
      c = _A$size2[1];

  if (index >= c) {
    throw new Error(OVERFLOW_COLUMN);
  }

  var matrix = A._matrix;
  return this.generate(r, 1, function (i) {
    return matrix[i][index];
  });
}

;
module.exports = column;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/utils/diag.js":
/*!**************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/utils/diag.js ***!
  \**************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var Matrix = __webpack_require__(/*! ../.. */ "./node_modules/@rayyamhk/matrix/lib/index.js");

var isNumber = __webpack_require__(/*! ../../util/isNumber */ "./node_modules/@rayyamhk/matrix/lib/util/isNumber.js");

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_ARRAY = _require.INVALID_ARRAY,
    EXPECTED_ARRAY_OF_NUMBERS_OR_MATRICES = _require.EXPECTED_ARRAY_OF_NUMBERS_OR_MATRICES,
    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX;
/**
 * Generates diagonal Matrix if the argument is an array of numbers,
 * generates block diagonal Matrix if the argument is an array of Matrices.
 * @memberof Matrix
 * @static
 * @param {(number[]|Matrix[])} values - Array of numbers or Matrices
 * @returns {Matrix} Block diagonal Matrix
 */


function diag(values) {
  if (!Array.isArray(values)) {
    throw new Error(INVALID_ARRAY);
  }

  var argsNum = values.length;
  var variant;

  for (var i = 0; i < argsNum; i++) {
    var entry = values[i];

    if (!isNumber(entry) && !(entry instanceof Matrix)) {
      throw new Error(EXPECTED_ARRAY_OF_NUMBERS_OR_MATRICES);
    }

    if (isNumber(entry)) {
      if (!variant) {
        variant = 'number';
        continue;
      }

      if (variant !== 'number') {
        throw new Error(EXPECTED_ARRAY_OF_NUMBERS_OR_MATRICES);
      }
    } else {
      if (!entry.isSquare()) {
        throw new Error(INVALID_SQUARE_MATRIX);
      }

      if (!variant) {
        variant = 'square';
        continue;
      }

      if (variant !== 'square') {
        throw new Error(EXPECTED_ARRAY_OF_NUMBERS_OR_MATRICES);
      }
    }
  } // HERE: variant should be either 'number' or 'square'


  if (variant === 'number') {
    return Matrix.generate(argsNum, argsNum, function (i, j) {
      if (i === j) {
        return values[i];
      }

      return 0;
    });
  } // Guaranteed that [values] is a list of square matrices


  var size = 0;
  var temp = new Array(argsNum);

  for (var _i = 0; _i < argsNum; _i++) {
    var _len = values[_i].size()[0];

    size += _len;
    temp[_i] = _len;
  }

  var idx = 0;
  var start = 0;
  var len = temp[idx];
  return Matrix.generate(size, size, function (i, j) {
    if (i - start === len && j - start === len) {
      start += len;
      idx++;
    }

    var ith = i - start; // ith < 0 if below main diagonal

    var jth = j - start; // jth < 0 if above main diagonal
    // skip 0x0 matrices

    len = temp[idx];

    while (len === 0) {
      idx++;
      len = temp[idx];
    }

    if (ith < len && ith >= 0 && jth < len && jth >= 0) {
      return values[idx]._matrix[ith][jth];
    }

    return 0;
  });
}

;
module.exports = diag;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/utils/elementwise.js":
/*!*********************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/utils/elementwise.js ***!
  \*********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX;
/**
 * This callback applies on each entry of a Matrix
 * @callback entryCallback
 * @param {number} entry - Entry of a Matrix
 * @returns {number} New entry value
 */

/**
 * Applys a function over each entry of a Matrix and returns
 * a new copy of the new Matrix.
 * @memberof Matrix
 * @static
 * @param {Matrix} A - Any Matrix
 * @param {entryCallback} cb - Callback function which applies on each entry of A
 * @returns {Matrix} A copy of new Matrix
 */


function elementwise(A, cb) {
  if (!(A instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  var _A$size = A.size(),
      _A$size2 = _slicedToArray(_A$size, 2),
      row = _A$size2[0],
      col = _A$size2[1];

  var matrix = A._matrix;
  return this.generate(row, col, function (i, j) {
    return cb(matrix[i][j]);
  });
}

;
module.exports = elementwise;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/utils/entry.js":
/*!***************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/utils/entry.js ***!
  \***************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_ROW_COL = _require.INVALID_ROW_COL,
    OVERFLOW_INDEX = _require.OVERFLOW_INDEX;
/**
 * Gets the entry of a Matrix.
 * @memberof Matrix
 * @instance
 * @param {number} row - Any valid row index
 * @param {number} col - Any valid column index
 * @returns {number} Entry of the Matrix
 */


function entry(row, col) {
  if (!Number.isInteger(row) || row < 0 || !Number.isInteger(col) || col < 0) {
    throw new Error(INVALID_ROW_COL);
  }

  var A = this._matrix;

  var _this$size = this.size(),
      _this$size2 = _slicedToArray(_this$size, 2),
      r = _this$size2[0],
      c = _this$size2[1];

  if (row >= r || col >= c) {
    throw new Error(OVERFLOW_INDEX);
  }

  return A[row][col];
}

;
module.exports = entry;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/utils/generate.js":
/*!******************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/utils/generate.js ***!
  \******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var empty = __webpack_require__(/*! ../../util/empty */ "./node_modules/@rayyamhk/matrix/lib/util/empty.js");
/**
 * This callback generates each entry of a Matrix
 * @callback generateCallback
 * @param {number} i - The i-th row of Matrix 
 * @param {number} j - The j-th column of Matrix 
 * @returns {number} Entry of Matrix
 */

/**
 * Generates a Matrix which entries are the returned value of callback function.
 * @memberof Matrix
 * @static
 * @param {number} row - Number of rows of Matrix
 * @param {number} col - Number of columns of Matrix
 * @param {generateCallback} cb - Callback function which takes row and column as arguments
 * and generates the corresponding entry
 * @returns {Matrix} - Generated Matrix
 */


function generate(row, col, cb) {
  var matrix = empty(row, col);

  if (row === 0 || col === 0) {
    return new this([]);
  }

  for (var i = 0; i < row; i++) {
    for (var j = 0; j < col; j++) {
      matrix[i][j] = cb(i, j);
    }
  }

  return new this(matrix);
}

;
module.exports = generate;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/utils/getDiag.js":
/*!*****************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/utils/getDiag.js ***!
  \*****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX;
/**
 * Gets the entries on the main diagonal.
 * @memberof Matrix
 * @static
 * @param {Matrix} A - Any Matrix
 * @returns {number[]} Array of entries of A on the main diagonal
 */


function getDiag(A) {
  if (!(A instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  var _A$size = A.size(),
      _A$size2 = _slicedToArray(_A$size, 2),
      row = _A$size2[0],
      col = _A$size2[1];

  var size = Math.min(row, col);
  var matrix = A._matrix;
  var diags = new Array(size);

  for (var i = 0; i < size; i++) {
    diags[i] = matrix[i][i];
  }

  return diags;
}

;
module.exports = getDiag;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/utils/getRandomMatrix.js":
/*!*************************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/utils/getRandomMatrix.js ***!
  \*************************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Generates a random Matrix.
 * @memberof Matrix
 * @static
 * @param {number} row - Number of rows of a Matrix
 * @param {number} col - Number of columns of a Matrix
 * @param {number} min - Lower bound of each entry
 * @param {number} max - Upper bound of each entry
 * @param {number} toFixed - Number of decimal places
 * @returns {Matrix} Generated random Matrix
 */
function getRandomMatrix(row, col) {
  var min = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
  var max = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
  var toFixed = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
  return this.generate(row, col, function () {
    return Number.parseFloat((Math.random() * (max - min) + min).toFixed(toFixed));
  });
}

;
module.exports = getRandomMatrix;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/utils/identity.js":
/*!******************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/utils/identity.js ***!
  \******************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Generates identity Matrix with given size.
 * @memberof Matrix
 * @static
 * @param {number} size - The size of Matrix
 * @returns {Matrix} Identity Matrix
 */
function identity(size) {
  return this.generate(size, size, function (i, j) {
    if (i === j) {
      return 1;
    }

    return 0;
  });
}

;
module.exports = identity;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/utils/isEqual.js":
/*!*****************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/utils/isEqual.js ***!
  \*****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX;
/**
 * Determines whether two Matrices are considered as equal.<br><br>
 * 
 * The test criterion is Math.abs(x - y) < 1 / (10 ** digit * 2).
 * For default value 5, it should be 5e-5.
 * That means if the difference of two numbers is less than 5e-5,
 * they are considered as same value.
 * @memberof Matrix
 * @static
 * @param {Matrix} A - Any Matrix
 * @param {Matrix} B - Any Matrix
 * @param {number} digit - Number of significant digits
 * @returns {boolean} Returns true if two Matrices are considered as same
 */


function isEqual(A, B) {
  var digit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 5;

  if (!(A instanceof this) || !(B instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  var _A$size = A.size(),
      _A$size2 = _slicedToArray(_A$size, 2),
      Arow = _A$size2[0],
      Acol = _A$size2[1];

  var _B$size = B.size(),
      _B$size2 = _slicedToArray(_B$size, 2),
      Brow = _B$size2[0],
      Bcol = _B$size2[1];

  if (Arow !== Brow || Acol !== Bcol) {
    return false;
  }

  var EPISILON = 1 / (Math.pow(10, digit) * 2);
  var matrixA = A._matrix;
  var matrixB = B._matrix;

  for (var i = 0; i < Arow; i++) {
    for (var j = 0; j < Acol; j++) {
      if (Math.abs(matrixA[i][j] - matrixB[i][j]) >= EPISILON) {
        return false;
      }
    }
  }

  return true;
}

;
module.exports = isEqual;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/utils/row.js":
/*!*************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/utils/row.js ***!
  \*************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_ROW_COL = _require.INVALID_ROW_COL,
    OVERFLOW_ROW = _require.OVERFLOW_ROW,
    INVALID_MATRIX = _require.INVALID_MATRIX;
/**
 * Gets the row of a Matrix with valid index.
 * @memberof Matrix
 * @static
 * @param {Matrix} A - Any Matrix
 * @param {number} index - Any valid row index
 * @returns {Matrix} Row of A
 */


function row(A, index) {
  if (!(A instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  if (!Number.isInteger(index) || index < 0) {
    throw new Error(INVALID_ROW_COL);
  }

  var _A$size = A.size(),
      _A$size2 = _slicedToArray(_A$size, 2),
      r = _A$size2[0],
      c = _A$size2[1];

  if (index >= r) {
    throw new Error(OVERFLOW_ROW);
  }

  var matrix = A._matrix;
  return this.generate(1, c, function (i, j) {
    return matrix[index][j];
  });
}

;
module.exports = row;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/utils/submatrix.js":
/*!*******************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/utils/submatrix.js ***!
  \*******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var _require = __webpack_require__(/*! ../../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX,
    EXPECTED_STRING_NUMBER_AT_POS_1_2 = _require.EXPECTED_STRING_NUMBER_AT_POS_1_2,
    INVALID_ROW = _require.INVALID_ROW,
    INVALID_COLUMN = _require.INVALID_COLUMN,
    OVERFLOW_ROW = _require.OVERFLOW_ROW,
    INVALID_ROWS_EXPRESSION = _require.INVALID_ROWS_EXPRESSION,
    INVALID_COLUMNS_EXPRESSION = _require.INVALID_COLUMNS_EXPRESSION,
    OVERFLOW_COLUMN = _require.OVERFLOW_COLUMN;
/**
 * Generates a submatrix of a matrix.
 * @memberof Matrix
 * @static
 * @param {Matrix} A - Any matrix
 * @param {string|number} rows - Rows expression
 * @param {string|number} cols - Columns expression
 * @returns {Matrix} Submatrix of A
 */


function submatrix(A, rows, cols) {
  if (!(A instanceof this)) {
    throw new Error(INVALID_MATRIX);
  }

  var arg1Type = _typeof(rows);

  var arg2Type = _typeof(cols);

  if (arg1Type !== 'string' && arg1Type !== 'number' || arg2Type !== 'string' && arg2Type !== 'number') {
    throw new Error(EXPECTED_STRING_NUMBER_AT_POS_1_2);
  }

  var _A$size = A.size(),
      _A$size2 = _slicedToArray(_A$size, 2),
      row = _A$size2[0],
      col = _A$size2[1];

  var rowStart;
  var rowEnd;
  var colStart;
  var colEnd;

  if (arg1Type === 'number') {
    if (!Number.isInteger(rows) || rows < 0) {
      throw new Error(INVALID_ROW);
    }

    if (rows >= row) {
      throw new Error(OVERFLOW_ROW);
    }

    rowStart = rows;
    rowEnd = rows;
  } else {
    // string
    var arg = rows.split(':');

    if (arg.length !== 2) {
      throw new Error(INVALID_ROWS_EXPRESSION);
    }

    var _arg = _slicedToArray(arg, 2),
        r1 = _arg[0],
        r2 = _arg[1];

    if (r1 === '') {
      rowStart = 0;
    } else {
      var r = Number(r1);

      if (!Number.isInteger(r) || r < 0) {
        throw new Error(INVALID_ROW);
      }

      if (r >= row) {
        throw new Error(OVERFLOW_ROW);
      }

      rowStart = r;
    }

    if (r2 === '') {
      rowEnd = row - 1;
    } else {
      var _r = Number(r2);

      if (!Number.isInteger(_r) || _r < 0) {
        throw new Error(INVALID_ROW);
      }

      if (_r >= row) {
        throw new Error(OVERFLOW_ROW);
      }

      rowEnd = _r;
    }

    if (rowStart > rowEnd) {
      throw new Error(INVALID_ROWS_EXPRESSION);
    }
  }

  if (arg2Type === 'number') {
    if (!Number.isInteger(cols) || cols < 0) {
      throw new Error(INVALID_COLUMN);
    }

    if (cols >= col) {
      throw new Error(OVERFLOW_COLUMN);
    }

    colStart = cols;
    colEnd = cols;
  } else {
    // string
    var _arg2 = cols.split(':');

    if (_arg2.length !== 2) {
      throw new Error(INVALID_COLUMNS_EXPRESSION);
    }

    var _arg3 = _slicedToArray(_arg2, 2),
        c1 = _arg3[0],
        c2 = _arg3[1];

    if (c1 === '') {
      colStart = 0;
    } else {
      var c = Number(c1);

      if (!Number.isInteger(c) || c < 0) {
        throw new Error(INVALID_COLUMN);
      }

      if (c >= col) {
        throw new Error(OVERFLOW_COLUMN);
      }

      colStart = c;
    }

    if (c2 === '') {
      colEnd = col - 1;
    } else {
      var _c = Number(c2);

      if (!Number.isInteger(_c) || _c < 0) {
        throw new Error(INVALID_COLUMN);
      }

      if (_c >= col) {
        throw new Error(OVERFLOW_COLUMN);
      }

      colEnd = _c;
    }

    if (colStart > colEnd) {
      throw new Error(INVALID_COLUMNS_EXPRESSION);
    }
  }

  var matrix = A._matrix;
  var subRow = rowEnd - rowStart + 1;
  var subCol = colEnd - colStart + 1;
  var subMatrix = new Array(subRow);

  for (var i = rowStart; i <= rowEnd; i++) {
    var newRow = new Array(subCol);

    for (var j = colStart; j <= colEnd; j++) {
      newRow[j - colStart] = matrix[i][j];
    }

    subMatrix[i - rowStart] = newRow;
  }

  return new this(subMatrix);
}

;
module.exports = submatrix;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/utils/toString.js":
/*!******************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/utils/toString.js ***!
  \******************************************************************/
/***/ ((module) => {

"use strict";


function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

/**
 * Gets the stringified Matrix
 * @memberof Matrix
 * @instance
 * @returns {string} Stringified Matrix
 */
function toString() {
  var matrix = this._matrix;

  var _this$size = this.size(),
      _this$size2 = _slicedToArray(_this$size, 2),
      row = _this$size2[0],
      col = _this$size2[1];

  var str = '';

  for (var i = 0; i < row; i++) {
    for (var j = 0; j < col; j++) {
      str += matrix[i][j].toString();

      if (j !== col - 1) {
        str += ' ';
      }
    }

    if (i !== row - 1) {
      str += '\n';
    }
  }

  return str;
}

;
module.exports = toString;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/core/utils/zero.js":
/*!**************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/core/utils/zero.js ***!
  \**************************************************************/
/***/ ((module) => {

"use strict";


/**
 * Generates a zero Matrix
 * @memberof Matrix
 * @static
 * @param {number} row - Number of rows of the Matrix
 * @param {number} col - Number of columns of the Matrix
 * @returns {Matrix} Zero Matrix
 */
function zero(row, col) {
  if (col === undefined) {
    return this.generate(row, row, function () {
      return 0;
    });
  }

  return this.generate(row, col, function () {
    return 0;
  });
}

;
module.exports = zero;

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/index.js":
/*!****************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/index.js ***!
  \****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var isMatrix = __webpack_require__(/*! ./util/isMatrix */ "./node_modules/@rayyamhk/matrix/lib/util/isMatrix.js");

var _require = __webpack_require__(/*! ./Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_MATRIX = _require.INVALID_MATRIX;
/**
 * Creates a new Matrix
 * @namespace Matrix
 * @class
 * @param {number[][]} A - Two dimensional array where
 * A[i][j] represents the i-th row and j-th column of a matrix
 */


function Matrix(A) {
  if (!isMatrix(A)) {
    throw new Error(INVALID_MATRIX);
  }

  this._matrix = A;
  this._digit = 8;
}

module.exports = Matrix; // structure

Matrix.prototype.isDiagonal = __webpack_require__(/*! ./core/structure/isDiagonal */ "./node_modules/@rayyamhk/matrix/lib/core/structure/isDiagonal.js");
Matrix.prototype.isSkewSymmetric = __webpack_require__(/*! ./core/structure/isSkewSymmetric */ "./node_modules/@rayyamhk/matrix/lib/core/structure/isSkewSymmetric.js");
Matrix.prototype.isSquare = __webpack_require__(/*! ./core/structure/isSquare */ "./node_modules/@rayyamhk/matrix/lib/core/structure/isSquare.js");
Matrix.prototype.isSymmetric = __webpack_require__(/*! ./core/structure/isSymmetric */ "./node_modules/@rayyamhk/matrix/lib/core/structure/isSymmetric.js");
Matrix.prototype.isLowerTriangular = __webpack_require__(/*! ./core/structure/isLowerTriangular */ "./node_modules/@rayyamhk/matrix/lib/core/structure/isLowerTriangular.js");
Matrix.prototype.isUpperTriangular = __webpack_require__(/*! ./core/structure/isUpperTriangular */ "./node_modules/@rayyamhk/matrix/lib/core/structure/isUpperTriangular.js");
Matrix.prototype.isOrthogonal = __webpack_require__(/*! ./core/structure/isOrthogonal */ "./node_modules/@rayyamhk/matrix/lib/core/structure/isOrthogonal.js"); // property

Matrix.prototype.cond = __webpack_require__(/*! ./core/properties/cond */ "./node_modules/@rayyamhk/matrix/lib/core/properties/cond.js");
Matrix.prototype.det = __webpack_require__(/*! ./core/properties/det */ "./node_modules/@rayyamhk/matrix/lib/core/properties/det.js");
Matrix.prototype.eigenvalues = __webpack_require__(/*! ./core/properties/eigenvalues */ "./node_modules/@rayyamhk/matrix/lib/core/properties/eigenvalues.js");
Matrix.prototype.nullity = __webpack_require__(/*! ./core/properties/nullity */ "./node_modules/@rayyamhk/matrix/lib/core/properties/nullity.js");
Matrix.prototype.norm = __webpack_require__(/*! ./core/properties/norm */ "./node_modules/@rayyamhk/matrix/lib/core/properties/norm.js");
Matrix.prototype.rank = __webpack_require__(/*! ./core/properties/rank */ "./node_modules/@rayyamhk/matrix/lib/core/properties/rank.js");
Matrix.prototype.size = __webpack_require__(/*! ./core/properties/size */ "./node_modules/@rayyamhk/matrix/lib/core/properties/size.js");
Matrix.prototype.trace = __webpack_require__(/*! ./core/properties/trace */ "./node_modules/@rayyamhk/matrix/lib/core/properties/trace.js"); // operations

Matrix.add = __webpack_require__(/*! ./core/operations/add */ "./node_modules/@rayyamhk/matrix/lib/core/operations/add.js");
Matrix.inverse = __webpack_require__(/*! ./core/operations/inverse */ "./node_modules/@rayyamhk/matrix/lib/core/operations/inverse.js");
Matrix.multiply = __webpack_require__(/*! ./core/operations/multiply */ "./node_modules/@rayyamhk/matrix/lib/core/operations/multiply.js");
Matrix.pow = __webpack_require__(/*! ./core/operations/pow */ "./node_modules/@rayyamhk/matrix/lib/core/operations/pow.js");
Matrix.subtract = __webpack_require__(/*! ./core/operations/subtract */ "./node_modules/@rayyamhk/matrix/lib/core/operations/subtract.js");
Matrix.transpose = __webpack_require__(/*! ./core/operations/transpose */ "./node_modules/@rayyamhk/matrix/lib/core/operations/transpose.js"); // Linear-equations

Matrix.backward = __webpack_require__(/*! ./core/linear-equations/backward */ "./node_modules/@rayyamhk/matrix/lib/core/linear-equations/backward.js");
Matrix.forward = __webpack_require__(/*! ./core/linear-equations/forward */ "./node_modules/@rayyamhk/matrix/lib/core/linear-equations/forward.js");
Matrix.solve = __webpack_require__(/*! ./core/linear-equations/solve */ "./node_modules/@rayyamhk/matrix/lib/core/linear-equations/solve.js"); // decompositions

Matrix.LU = __webpack_require__(/*! ./core/decompositions/LU */ "./node_modules/@rayyamhk/matrix/lib/core/decompositions/LU.js");
Matrix.QR = __webpack_require__(/*! ./core/decompositions/QR */ "./node_modules/@rayyamhk/matrix/lib/core/decompositions/QR.js"); // utils

Matrix.clone = __webpack_require__(/*! ./core/utils/clone */ "./node_modules/@rayyamhk/matrix/lib/core/utils/clone.js");
Matrix.column = __webpack_require__(/*! ./core/utils/column */ "./node_modules/@rayyamhk/matrix/lib/core/utils/column.js");
Matrix.diag = __webpack_require__(/*! ./core/utils/diag */ "./node_modules/@rayyamhk/matrix/lib/core/utils/diag.js");
Matrix.elementwise = __webpack_require__(/*! ./core/utils/elementwise */ "./node_modules/@rayyamhk/matrix/lib/core/utils/elementwise.js");
Matrix.generate = __webpack_require__(/*! ./core/utils/generate */ "./node_modules/@rayyamhk/matrix/lib/core/utils/generate.js");
Matrix.getDiag = __webpack_require__(/*! ./core/utils/getDiag */ "./node_modules/@rayyamhk/matrix/lib/core/utils/getDiag.js");
Matrix.getRandomMatrix = __webpack_require__(/*! ./core/utils/getRandomMatrix */ "./node_modules/@rayyamhk/matrix/lib/core/utils/getRandomMatrix.js");
Matrix.identity = __webpack_require__(/*! ./core/utils/identity */ "./node_modules/@rayyamhk/matrix/lib/core/utils/identity.js");
Matrix.isEqual = __webpack_require__(/*! ./core/utils/isEqual */ "./node_modules/@rayyamhk/matrix/lib/core/utils/isEqual.js");
Matrix.row = __webpack_require__(/*! ./core/utils/row */ "./node_modules/@rayyamhk/matrix/lib/core/utils/row.js");
Matrix.submatrix = __webpack_require__(/*! ./core/utils/submatrix */ "./node_modules/@rayyamhk/matrix/lib/core/utils/submatrix.js");
Matrix.zero = __webpack_require__(/*! ./core/utils/zero */ "./node_modules/@rayyamhk/matrix/lib/core/utils/zero.js");
Matrix.prototype.entry = __webpack_require__(/*! ./core/utils/entry */ "./node_modules/@rayyamhk/matrix/lib/core/utils/entry.js");
Matrix.prototype.toString = __webpack_require__(/*! ./core/utils/toString */ "./node_modules/@rayyamhk/matrix/lib/core/utils/toString.js");

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/util/empty.js":
/*!*********************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/util/empty.js ***!
  \*********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var _require = __webpack_require__(/*! ../Error */ "./node_modules/@rayyamhk/matrix/lib/Error.js"),
    INVALID_ROW_COL = _require.INVALID_ROW_COL;

module.exports = function empty(row, col) {
  if (!Number.isInteger(row) || row < 0 || !Number.isInteger(col) || col < 0) {
    throw new Error(INVALID_ROW_COL);
  }

  if (row === 0 || col === 0) {
    return [];
  }

  var matrix = new Array(row);

  for (var i = 0; i < row; i++) {
    matrix[i] = new Array(col);
  }

  return matrix;
};

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/util/isMatrix.js":
/*!************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/util/isMatrix.js ***!
  \************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var isNumber = __webpack_require__(/*! ./isNumber */ "./node_modules/@rayyamhk/matrix/lib/util/isNumber.js");

module.exports = function isMatrix(matrix) {
  if (!Array.isArray(matrix)) {
    return false;
  }

  var height = matrix.length;

  if (height === 0) {
    return true; // [] represents empty matrix (0 x 0 matrix)
  }

  var firstRow = matrix[0];

  if (!Array.isArray(firstRow)) {
    return false;
  }

  var width = firstRow.length;

  if (width === 0) {
    return false; // [ [] ] is not allowed
  }

  for (var i = 0; i < height; i++) {
    var row = matrix[i];

    if (!Array.isArray(row) || row.length !== width) {
      return false;
    }

    for (var j = 0; j < width; j++) {
      if (!isNumber(row[j])) {
        return false;
      }
    }
  }

  return true;
};

/***/ }),

/***/ "./node_modules/@rayyamhk/matrix/lib/util/isNumber.js":
/*!************************************************************!*\
  !*** ./node_modules/@rayyamhk/matrix/lib/util/isNumber.js ***!
  \************************************************************/
/***/ ((module) => {

"use strict";


module.exports = function isNumber(_int) {
  return Number.isFinite(_int);
};

/***/ }),

/***/ "./node_modules/matrix-inverse/matrix-inverse.js":
/*!*******************************************************!*\
  !*** ./node_modules/matrix-inverse/matrix-inverse.js ***!
  \*******************************************************/
/***/ ((module) => {

var Sylvester = {}

Sylvester.Matrix = function () {}

Sylvester.Matrix.create = function (elements) {
  var M = new Sylvester.Matrix()
  return M.setElements(elements)
}

Sylvester.Matrix.I = function (n) {
  var els = [],
    i = n,
    j
  while (i--) {
    j = n
    els[i] = []
    while (j--) {
      els[i][j] = i === j ? 1 : 0
    }
  }
  return Sylvester.Matrix.create(els)
}

Sylvester.Matrix.prototype = {
  dup: function () {
    return Sylvester.Matrix.create(this.elements)
  },

  isSquare: function () {
    var cols = this.elements.length === 0 ? 0 : this.elements[0].length
    return this.elements.length === cols
  },

  toRightTriangular: function () {
    if (this.elements.length === 0) return Sylvester.Matrix.create([])
    var M = this.dup(),
      els
    var n = this.elements.length,
      i,
      j,
      np = this.elements[0].length,
      p
    for (i = 0; i < n; i++) {
      if (M.elements[i][i] === 0) {
        for (j = i + 1; j < n; j++) {
          if (M.elements[j][i] !== 0) {
            els = []
            for (p = 0; p < np; p++) {
              els.push(M.elements[i][p] + M.elements[j][p])
            }
            M.elements[i] = els
            break
          }
        }
      }
      if (M.elements[i][i] !== 0) {
        for (j = i + 1; j < n; j++) {
          var multiplier = M.elements[j][i] / M.elements[i][i]
          els = []
          for (p = 0; p < np; p++) {
            // Elements with column numbers up to an including the number of the
            // row that we're subtracting can safely be set straight to zero,
            // since that's the point of this routine and it avoids having to
            // loop over and correct rounding errors later
            els.push(
              p <= i ? 0 : M.elements[j][p] - M.elements[i][p] * multiplier
            )
          }
          M.elements[j] = els
        }
      }
    }
    return M
  },

  determinant: function () {
    if (this.elements.length === 0) {
      return 1
    }
    if (!this.isSquare()) {
      return null
    }
    var M = this.toRightTriangular()
    var det = M.elements[0][0],
      n = M.elements.length
    for (var i = 1; i < n; i++) {
      det = det * M.elements[i][i]
    }
    return det
  },

  isSingular: function () {
    return this.isSquare() && this.determinant() === 0
  },

  augment: function (matrix) {
    if (this.elements.length === 0) {
      return this.dup()
    }
    var M = matrix.elements || matrix
    if (typeof M[0][0] === 'undefined') {
      M = Sylvester.Matrix.create(M).elements
    }
    var T = this.dup(),
      cols = T.elements[0].length
    var i = T.elements.length,
      nj = M[0].length,
      j
    if (i !== M.length) {
      return null
    }
    while (i--) {
      j = nj
      while (j--) {
        T.elements[i][cols + j] = M[i][j]
      }
    }
    return T
  },

  inverse: function () {
    if (this.elements.length === 0) {
      return null
    }
    if (!this.isSquare() || this.isSingular()) {
      return null
    }
    var n = this.elements.length,
      i = n,
      j
    var M = this.augment(Sylvester.Matrix.I(n)).toRightTriangular()
    var np = M.elements[0].length,
      p,
      els,
      divisor
    var inverse_elements = [],
      new_element
    // Sylvester.Matrix is non-singular so there will be no zeros on the
    // diagonal. Cycle through rows from last to first.
    while (i--) {
      // First, normalise diagonal elements to 1
      els = []
      inverse_elements[i] = []
      divisor = M.elements[i][i]
      for (p = 0; p < np; p++) {
        new_element = M.elements[i][p] / divisor
        els.push(new_element)
        // Shuffle off the current row of the right hand side into the results
        // array as it will not be modified by later runs through this loop
        if (p >= n) {
          inverse_elements[i].push(new_element)
        }
      }
      M.elements[i] = els
      // Then, subtract this row from those above it to give the identity matrix
      // on the left hand side
      j = i
      while (j--) {
        els = []
        for (p = 0; p < np; p++) {
          els.push(M.elements[j][p] - M.elements[i][p] * M.elements[j][i])
        }
        M.elements[j] = els
      }
    }
    return Sylvester.Matrix.create(inverse_elements)
  },

  setElements: function (els) {
    var i,
      j,
      elements = els.elements || els
    if (elements[0] && typeof elements[0][0] !== 'undefined') {
      i = elements.length
      this.elements = []
      while (i--) {
        j = elements[i].length
        this.elements[i] = []
        while (j--) {
          this.elements[i][j] = elements[i][j]
        }
      }
      return this
    }
    var n = elements.length
    this.elements = []
    for (i = 0; i < n; i++) {
      this.elements.push([elements[i]])
    }
    return this
  },
}

module.exports = function (elements) {
  const mat = Sylvester.Matrix.create(elements).inverse()
  if (mat !== null) {
    return mat.elements
  } else {
    return null
  }
}


/***/ }),

/***/ "./node_modules/simple-linalg/index.js":
/*!*********************************************!*\
  !*** ./node_modules/simple-linalg/index.js ***!
  \*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

module.exports = __webpack_require__(/*! ./lib/index.js */ "./node_modules/simple-linalg/lib/index.js");


/***/ }),

/***/ "./node_modules/simple-linalg/lib/add.js":
/*!***********************************************!*\
  !*** ./node_modules/simple-linalg/lib/add.js ***!
  \***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const elemWise = __webpack_require__(/*! ./elem-wise */ "./node_modules/simple-linalg/lib/elem-wise.js");
/**
* Add matrixes together
* @param {...Array.<Array.<Number>>} args list of matrix
* @returns {Array.<Array.<Number>>} sum
*/
module.exports = function (...args) {
	return elemWise(args, args2 => {
		return args2.reduce((a, b) => {
			if (a === null || b === null) {
				return null;
			}

			return a + b;
		}, 0);
	});
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/cos-similarity.js":
/*!**********************************************************!*\
  !*** ./node_modules/simple-linalg/lib/cos-similarity.js ***!
  \**********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const dotProduct = __webpack_require__(/*! ./dot-product.js */ "./node_modules/simple-linalg/lib/dot-product.js");
const norm = __webpack_require__(/*! ./norm.js */ "./node_modules/simple-linalg/lib/norm.js");

module.exports = function (vector1, vector2) {
	if (vector1.length !== vector2.length) {
		throw (new Error('The lengths of the vectors do not match'));
	}

	return dotProduct(vector1, vector2) / (norm(vector1) * norm(vector2));
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/diag-block.js":
/*!******************************************************!*\
  !*** ./node_modules/simple-linalg/lib/diag-block.js ***!
  \******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const identity = __webpack_require__(/*! ./identity.js */ "./node_modules/simple-linalg/lib/identity.js");

module.exports = function ({blocks, order = null}) {
	const dimL = blocks.map(a => a.length).reduce((a, b) => a + b, 0);
	const result = identity(dimL);
	let current = 0;
	for (const mat of blocks) {
		for (const [i] of mat.entries()) {
			for (const [j] of mat.entries()) {
				result[i + current][j + current] = mat[i][j];
			}
		}

		current += mat.length;
	}

	if (order) {
		return order.map(i => order.map(j => result[i][j]));
	}

	return result;
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/diag.js":
/*!************************************************!*\
  !*** ./node_modules/simple-linalg/lib/diag.js ***!
  \************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const zeros = __webpack_require__(/*! ./zeros */ "./node_modules/simple-linalg/lib/zeros.js");

module.exports = function (mat) {
	const result = zeros(mat.length, mat.length);

	for (const [i, element] of mat.entries()) {
		result[i][i] = element;
	}

	return result;
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/dot-product.js":
/*!*******************************************************!*\
  !*** ./node_modules/simple-linalg/lib/dot-product.js ***!
  \*******************************************************/
/***/ ((module) => {

module.exports = function (vector1, vector2) {
	if (vector1.length !== vector2.length) {
		throw (new Error('Lengths not maching'));
	}

	let result = 0;
	for (const [i, element] of vector1.entries()) {
		result += element * vector2[i];
	}

	return result;
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/elem-wise.js":
/*!*****************************************************!*\
  !*** ./node_modules/simple-linalg/lib/elem-wise.js ***!
  \*****************************************************/
/***/ ((module) => {

/**
* @callback elemWiseCb
* @param {Array.<Number>} arr
* @param {Number} rowId
* @param {Number} colId
*/
/**
* run a function on cell per cell for each Matrixes
* @param {<Array.<Array.<Array.<Number>>>} arrMatrixes list of matrixes
* @param {elemWiseCb} fn
* @returns {Array.<Array.<Number>>} resulting matrix
* @example
// this will do m1 + m2 + m3 + m4 on matrixes
elemWise([m1, m2, m3, m4], args2 => {
	return args2.reduce((a, b) => a + b, 0);
});
*/

module.exports = function (arrayMatrixes, fn) {
	return arrayMatrixes[0].map((row, rowId) => {
		return row.map((cell, colId) => {
			const array = arrayMatrixes.map(m => m[rowId][colId]);
			return fn(array, rowId, colId);
		});
	});
};



/***/ }),

/***/ "./node_modules/simple-linalg/lib/euclidean-dist.js":
/*!**********************************************************!*\
  !*** ./node_modules/simple-linalg/lib/euclidean-dist.js ***!
  \**********************************************************/
/***/ ((module) => {

module.exports = function (array1, array2) {
	if (array1.length !== array2.length) {
		throw new Error('Invalid array lengths');
	}

	const diff = array1.map((element, index) => element - array2[index]).map(element => element * element);
	return Math.sqrt(diff.reduce((a, b) => a + b));
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/frobenius.js":
/*!*****************************************************!*\
  !*** ./node_modules/simple-linalg/lib/frobenius.js ***!
  \*****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const trace = __webpack_require__(/*! ./trace.js */ "./node_modules/simple-linalg/lib/trace.js");
const transpose = __webpack_require__(/*! ./transpose.js */ "./node_modules/simple-linalg/lib/transpose.js");
const matSub = __webpack_require__(/*! ./subtract.js */ "./node_modules/simple-linalg/lib/subtract.js");
const matMul = __webpack_require__(/*! ./mat-mul.js */ "./node_modules/simple-linalg/lib/mat-mul.js");
const sum = __webpack_require__(/*! ./sum.js */ "./node_modules/simple-linalg/lib/sum.js");

// [Frobenius norm](https://en.wikipedia.org/wiki/Matrix_norm#Frobenius_norm )
module.exports = function (array1, array2) {
	if (array1 === undefined) {
		return sum(array2);
	}

	if (array2 === undefined) {
		return sum(array1);
	}

	const m = matSub(array1, array2);
	const p = matMul(transpose(m), m);
	return Math.sqrt(trace(p));
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/identity.js":
/*!****************************************************!*\
  !*** ./node_modules/simple-linalg/lib/identity.js ***!
  \****************************************************/
/***/ ((module) => {

module.exports = function (stateSize) {
	const identityArray = [];
	for (let i = 0; i < stateSize; i++) {
		const rowIdentity = [];
		for (let j = 0; j < stateSize; j++) {
			if (i === j) {
				rowIdentity.push(1);
			} else {
				rowIdentity.push(0);
			}
		}

		identityArray.push(rowIdentity);
	}

	return identityArray;
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/index.js":
/*!*************************************************!*\
  !*** ./node_modules/simple-linalg/lib/index.js ***!
  \*************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

module.exports = {
	add: __webpack_require__(/*! ./add.js */ "./node_modules/simple-linalg/lib/add.js"),
	cosSimilarity: __webpack_require__(/*! ./cos-similarity */ "./node_modules/simple-linalg/lib/cos-similarity.js"),
	euclideanDist: __webpack_require__(/*! ./euclidean-dist */ "./node_modules/simple-linalg/lib/euclidean-dist.js"),
	diag: __webpack_require__(/*! ./diag.js */ "./node_modules/simple-linalg/lib/diag.js"),
	diagBlock: __webpack_require__(/*! ./diag-block */ "./node_modules/simple-linalg/lib/diag-block.js"),
	dotProduct: __webpack_require__(/*! ./dot-product */ "./node_modules/simple-linalg/lib/dot-product.js"),
	elemWise: __webpack_require__(/*! ./elem-wise.js */ "./node_modules/simple-linalg/lib/elem-wise.js"),
	frobenius: __webpack_require__(/*! ./frobenius.js */ "./node_modules/simple-linalg/lib/frobenius.js"),
	identity: __webpack_require__(/*! ./identity.js */ "./node_modules/simple-linalg/lib/identity.js"),
	invert: __webpack_require__(/*! ./invert.js */ "./node_modules/simple-linalg/lib/invert.js"),
	mapMatrix: __webpack_require__(/*! ./map-matrix.js */ "./node_modules/simple-linalg/lib/map-matrix.js"),
	matMul: __webpack_require__(/*! ./mat-mul.js */ "./node_modules/simple-linalg/lib/mat-mul.js"),
	matPermutation: __webpack_require__(/*! ./mat-permutation.js */ "./node_modules/simple-linalg/lib/mat-permutation.js"),
	padWithZeroCols: __webpack_require__(/*! ./pad-with-zero-cols.js */ "./node_modules/simple-linalg/lib/pad-with-zero-cols.js"),
	subtract: __webpack_require__(/*! ./subtract.js */ "./node_modules/simple-linalg/lib/subtract.js"),
	subSquareMatrix: __webpack_require__(/*! ./sub-square-matrix.js */ "./node_modules/simple-linalg/lib/sub-square-matrix.js"),
	sum: __webpack_require__(/*! ./sum.js */ "./node_modules/simple-linalg/lib/sum.js"),
	trace: __webpack_require__(/*! ./trace.js */ "./node_modules/simple-linalg/lib/trace.js"),
	transpose: __webpack_require__(/*! ./transpose.js */ "./node_modules/simple-linalg/lib/transpose.js"),
	zeros: __webpack_require__(/*! ./zeros.js */ "./node_modules/simple-linalg/lib/zeros.js"),
	norm: __webpack_require__(/*! ./norm.js */ "./node_modules/simple-linalg/lib/norm.js"),
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/invert.js":
/*!**************************************************!*\
  !*** ./node_modules/simple-linalg/lib/invert.js ***!
  \**************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const matrixInverse = __webpack_require__(/*! matrix-inverse */ "./node_modules/matrix-inverse/matrix-inverse.js");

module.exports = function (m) {
	return matrixInverse(m);
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/map-matrix.js":
/*!******************************************************!*\
  !*** ./node_modules/simple-linalg/lib/map-matrix.js ***!
  \******************************************************/
/***/ ((module) => {

module.exports = function (a, fn) {
	return a.map((row, rowId) => row.map((cell, colId) => fn(cell, rowId, colId)));
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/mat-mul.js":
/*!***************************************************!*\
  !*** ./node_modules/simple-linalg/lib/mat-mul.js ***!
  \***************************************************/
/***/ ((module) => {

/**
* Multiply 2 matrixes together
* @param {Array.<Array.<Number>>} m1
* @param {Array.<Array.<Number>>} m2
* @returns {Array.<Array.<Number>>}
*/
module.exports = function (m1, m2) {
	// Console.log({m1, m2});
	const result = [];
	for (let i = 0; i < m1.length; i++) {
		result[i] = [];
		for (let j = 0; j < m2[0].length; j++) {
			let sum = 0;
			let isNull = false;
			for (let k = 0; k < m1[0].length; k++) {
				if ((m1[i][k] === null && m2[k][j] !== 0) || (m2[k][j] === null && m1[i][k] !== 0)) {
					isNull = true;
				}

				sum += m1[i][k] * m2[k][j];
			}

			result[i][j] = isNull ? null : sum;
		}
	}

	return result;
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/mat-permutation.js":
/*!***********************************************************!*\
  !*** ./node_modules/simple-linalg/lib/mat-permutation.js ***!
  \***********************************************************/
/***/ ((module) => {

/**
 *
 * @param {Array.<Array.<Number>>} matrix
 * @param {[Number, Number]} outputSize
 * @param {Array.<Number>} rowIndexes the permutation indexes, result[j][k] = matrix[rowIndexes.indexOf(j)][colIndexes.indexOf(k)]
 * @param {Array.<Number>} colIndexes the permutation indexes, result[j][k] = matrix[rowIndexes.indexOf(j)][colIndexes.indexOf(k)]
 * @returns {Array.<Array.<Number>>}
 */
module.exports = function ({
	matrix,
	outputSize,
	rowIndexes,
	colIndexes,
}) {
	const [nRow, nCol] = outputSize;

	if (!Array.isArray(rowIndexes)) {
		throw (new TypeError(`Invalid rowIndexes ${rowIndexes}`));
	}

	if (!Array.isArray(colIndexes)) {
		throw (new TypeError(`Invalid colIndexes ${colIndexes}`));
	}

	return new Array(nRow).fill(0).map((_, i) => new Array(nCol).fill(0).map((_, j) => {
		if (colIndexes.includes(j) && rowIndexes.includes(i)) {
			return matrix[rowIndexes.indexOf(i)][colIndexes.indexOf(j)];
		}

		return 0;
	}));
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/norm.js":
/*!************************************************!*\
  !*** ./node_modules/simple-linalg/lib/norm.js ***!
  \************************************************/
/***/ ((module) => {

module.exports = function (vector) {
	let result = 0;
	for (const element of vector) {
		result += (element * element);
	}

	return Math.sqrt(result);
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/pad-with-zero-cols.js":
/*!**************************************************************!*\
  !*** ./node_modules/simple-linalg/lib/pad-with-zero-cols.js ***!
  \**************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const matPermutation = __webpack_require__(/*! ./mat-permutation */ "./node_modules/simple-linalg/lib/mat-permutation.js");
/**
*This function returns the padded matrix with zeros with respect to a given
* target columns number
*@param {Array.<Array.<Number>>} matrix the matrix we need to pad
*@param {Number} columns in our case, the dynamic dimension
*@returns {Array.<Array.<Number>>} padded matrix
*/
module.exports = function (matrix, {columns}) {
	if (columns < matrix[0].length) {
		throw (new TypeError(`Output columns ${columns} is greater than input columns ${matrix[0].length}`));
	}

	return matPermutation({
		matrix,
		outputSize: [matrix.length, columns],
		rowIndexes: new Array(matrix.length).fill(0).map((_, index) => index),
		colIndexes: new Array(matrix[0].length).fill(0).map((_, index) => index),
	});
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/sub-square-matrix.js":
/*!*************************************************************!*\
  !*** ./node_modules/simple-linalg/lib/sub-square-matrix.js ***!
  \*************************************************************/
/***/ ((module) => {

module.exports = (mat, indexes) => {
	return indexes.map(s1 => indexes.map(s2 => mat[s1][s2]));
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/subtract.js":
/*!****************************************************!*\
  !*** ./node_modules/simple-linalg/lib/subtract.js ***!
  \****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const elemWise = __webpack_require__(/*! ./elem-wise */ "./node_modules/simple-linalg/lib/elem-wise.js");

module.exports = function (...args) {
	return elemWise(args, ([a, b]) => a - b);
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/sum.js":
/*!***********************************************!*\
  !*** ./node_modules/simple-linalg/lib/sum.js ***!
  \***********************************************/
/***/ ((module) => {

// Sum all the terms of a given matrix
module.exports = function (array) {
	let s = 0;
	for (let i = 0; i < array.length; i++) {
		for (let j = 0; j < array.length; j++) {
			s += array[i][j];
		}
	}

	return s;
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/trace.js":
/*!*************************************************!*\
  !*** ./node_modules/simple-linalg/lib/trace.js ***!
  \*************************************************/
/***/ ((module) => {

module.exports = function (array) {
	let diag = 0;
	for (const [row, element] of array.entries()) {
		diag += element[row];
	}

	return diag;
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/transpose.js":
/*!*****************************************************!*\
  !*** ./node_modules/simple-linalg/lib/transpose.js ***!
  \*****************************************************/
/***/ ((module) => {

module.exports = function (array) {
	return array[0].map((col, i) => array.map(row => row[i]));
};


/***/ }),

/***/ "./node_modules/simple-linalg/lib/zeros.js":
/*!*************************************************!*\
  !*** ./node_modules/simple-linalg/lib/zeros.js ***!
  \*************************************************/
/***/ ((module) => {

module.exports = function (rows, cols) {
	return new Array(rows).fill(1).map(() => new Array(cols).fill(0));
};


/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
/******/ 	
/******/ 	// startup
/******/ 	// Load entry module and return exports
/******/ 	// This entry module is referenced by other modules so it can't be inlined
/******/ 	var __webpack_exports__ = __webpack_require__("./index.js");
/******/ 	kalmanFilter = __webpack_exports__;
/******/ 	
/******/ })()
;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"kalman-filter.js","mappings":"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CA;AACA;AACA;AACA;AACA;;AAEA,SAAS,kBAAkB,SAAS;AACpC;AACA;AACA,wBAAwB,MAAM,eAAe,MAAM,iBAAiB,eAAe,qCAAqC,UAAU;AAClI;;AAEA;AACA;AACA,mBAAmB,kBAAkB;AACrC;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,wBAAwB;AACnC,aAAa;AACb;AACA,gBAAgB,cAAc;AAC9B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA,WAAW,gBAAgB;AAC3B,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA,aAAa,QAAQ;AACrB,cAAc,kBAAkB;AAChC,cAAc,wBAAwB;AACtC,cAAc,QAAQ;AACtB;AACA;AACA;AACA,WAAW,kBAAkB;AAC7B,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,YAAY;AAC3B,gDAAgD,gCAAgC;AAChF;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,0CAA0C;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,cAAc;AACzB,WAAW,aAAa;AACxB,WAAW,gBAAgB;AAC3B,aAAa;AACb;AACA,sBAAsB,4BAA4B;AAClD;AACA,+CAA+C,aAAa,cAAc,mBAAmB,kDAAkD,yBAAyB;AACxK;;AAEA,iDAAiD,2CAA2C;;AAE5F,wEAAwE;;AAExE,gDAAgD,qCAAqC;;AAErF;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,WAAW,QAAQ;AACnB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,cAAc;AACzB,WAAW,OAAO;AAClB,WAAW,gBAAgB;AAC3B,aAAa;AACb;AACA,mBAAmB,sBAAsB;AACzC,wEAAwE;;AAExE,oDAAoD,qCAAqC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A;AACA,GAAG;AACH;;;;;;;;;;;ACpCA,UAAU,MAAM;;AAEhB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS,yCAAyC;AAClD,WAAW;AACX;;AAEA,mCAAmC,cAAc,IAAI;AACrD;AACA;AACA;;AAEA;AACA;AACA;;AAEA,qBAAqB,oCAAoC,kDAAkD,MAAM;AACjH;;;;;;;;;;;ACzBA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACJa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;ACrDa;;AAEb;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACZa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfa;;AAEb;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACZa;;AAEb;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;ACnDa;;AAEb;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACba;;AAEb;AACA;AACA,wCAAwC,YAAY;AACpD;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBa;;AAEb;AACA;AACA,wCAAwC,GAAG;AAC3C;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBa;;AAEb;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;AClBa;;AAEb;AACA;AACA,wCAAwC,GAAG;AAC3C;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBa;;AAEb;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACba;;AAEb;AACA;AACA,wCAAwC,QAAQ;AAChD;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBa;;AAEb;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;ACjBa;;AAEb;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBa;;AAEb;AACA;AACA,wCAAwC,yBAAyB;AACjE;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBa;;AAEb;AACA;AACA,wCAAwC,uBAAuB;AAC/D;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;AC/Ba;;AAEb;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpBa;;AAEb;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;ACjBa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;AC3Ca;;AAEb;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;ACxBa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;AC5Ba;;AAEb;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACtBa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,gBAAgB;AAC3B,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AAC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EA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA;;AAEA;AACA;;;;;;;;;;;AC1Ca;;AAEb;AACA;AACA;;;;;;;;;;ACJA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,OAAO;AACvB;AACA,wBAAwB,OAAO;AAC/B;AACA;AACA,wBAAwB,QAAQ;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B;AACA;AACA,sBAAsB,QAAQ;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,QAAQ;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,OAAO;AACvB;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA,IAAI;AAC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","sources":["webpack://kalmanFilter/./index.js","webpack://kalmanFilter/./lib/core-kalman-filter.js","webpack://kalmanFilter/./lib/dynamic/composition.js","webpack://kalmanFilter/./lib/dynamic/constant-acceleration.js","webpack://kalmanFilter/./lib/dynamic/constant-position-with-null.js","webpack://kalmanFilter/./lib/dynamic/constant-position.js","webpack://kalmanFilter/./lib/dynamic/constant-speed-dynamic.js","webpack://kalmanFilter/./lib/dynamic/constant-speed-with-null.js","webpack://kalmanFilter/./lib/dynamic/constant-speed.js","webpack://kalmanFilter/./lib/dynamic/index.js","webpack://kalmanFilter/./lib/dynamic/shortterm-constant-speed.js","webpack://kalmanFilter/./lib/kalman-filter.js","webpack://kalmanFilter/./lib/model-collection.js","webpack://kalmanFilter/./lib/observation/index.js","webpack://kalmanFilter/./lib/observation/sensor-local-variance.js","webpack://kalmanFilter/./lib/observation/sensor-projected.js","webpack://kalmanFilter/./lib/observation/sensor.js","webpack://kalmanFilter/./lib/setup/build-state-projection.js","webpack://kalmanFilter/./lib/setup/check-dimensions.js","webpack://kalmanFilter/./lib/setup/extend-dynamic-init.js","webpack://kalmanFilter/./lib/setup/set-dimensions.js","webpack://kalmanFilter/./lib/state.js","webpack://kalmanFilter/./lib/utils/array-to-matrix.js","webpack://kalmanFilter/./lib/utils/check-covariance.js","webpack://kalmanFilter/./lib/utils/check-matrix.js","webpack://kalmanFilter/./lib/utils/check-shape.js","webpack://kalmanFilter/./lib/utils/correlation-to-covariance.js","webpack://kalmanFilter/./lib/utils/covariance-to-correlation.js","webpack://kalmanFilter/./lib/utils/deep-assign.js","webpack://kalmanFilter/./lib/utils/get-covariance.js","webpack://kalmanFilter/./lib/utils/polymorph-matrix.js","webpack://kalmanFilter/./lib/utils/project-observation.js","webpack://kalmanFilter/./lib/utils/to-function.js","webpack://kalmanFilter/./lib/utils/uniq.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/instance/getArgument.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/instance/getImaginary.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/instance/getModulus.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/instance/getReal.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/instance/toString.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/acos.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/acot.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/acsc.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/add.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/asec.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/asin.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/atan.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/conjugate.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/cos.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/cot.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/csc.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/divide.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/exp.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/inverse.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/isEqual.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/isNaN.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/log.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/multiply.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/pow.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/sec.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/sin.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/subtract.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/core/static/tan.js","webpack://kalmanFilter/./node_modules/@rayyamhk/complex/lib/index.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/Error.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/decompositions/LU.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/decompositions/QR.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/linear-equations/backward.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/linear-equations/forward.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/linear-equations/solve.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/operations/add.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/operations/inverse.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/operations/multiply.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/operations/pow.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/operations/subtract.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/operations/transpose.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/properties/cond.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/properties/det.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/properties/eigenvalues.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/properties/norm.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/properties/nullity.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/properties/rank.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/properties/size.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/properties/trace.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/structure/isDiagonal.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/structure/isLowerTriangular.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/structure/isOrthogonal.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/structure/isSkewSymmetric.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/structure/isSquare.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/structure/isSymmetric.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/structure/isUpperTriangular.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/utils/clone.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/utils/column.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/utils/diag.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/utils/elementwise.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/utils/entry.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/utils/generate.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/utils/getDiag.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/utils/getRandomMatrix.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/utils/identity.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/utils/isEqual.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/utils/row.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/utils/submatrix.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/utils/toString.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/core/utils/zero.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/index.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/util/empty.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/util/isMatrix.js","webpack://kalmanFilter/./node_modules/@rayyamhk/matrix/lib/util/isNumber.js","webpack://kalmanFilter/./node_modules/matrix-inverse/matrix-inverse.js","webpack://kalmanFilter/./node_modules/simple-linalg/index.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/add.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/cos-similarity.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/diag-block.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/diag.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/dot-product.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/elem-wise.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/euclidean-dist.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/frobenius.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/identity.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/index.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/invert.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/map-matrix.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/mat-mul.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/mat-permutation.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/norm.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/pad-with-zero-cols.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/sub-square-matrix.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/subtract.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/sum.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/trace.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/transpose.js","webpack://kalmanFilter/./node_modules/simple-linalg/lib/zeros.js","webpack://kalmanFilter/webpack/bootstrap","webpack://kalmanFilter/webpack/before-startup","webpack://kalmanFilter/webpack/startup","webpack://kalmanFilter/webpack/after-startup"],"sourcesContent":["const modelCollection = require('./lib/model-collection');\nconst defaultDynamicModels = require('./lib/dynamic');\nconst defaultObservationModels = require('./lib/observation');\n\nObject.keys(defaultDynamicModels).forEach(k => {\n\tmodelCollection.registerDynamic(k, defaultDynamicModels[k]);\n});\n\nObject.keys(defaultObservationModels).forEach(k => {\n\tmodelCollection.registerObservation(k, defaultObservationModels[k]);\n});\n\nmodule.exports = Object.assign({\n\tKalmanFilter: require('./lib/kalman-filter'),\n\tgetCovariance: require('./lib/utils/get-covariance'),\n\tState: require('./lib/state'),\n\tcheckCovariance: require('./lib/utils/check-covariance'),\n\tcorrelationToCovariance: require('./lib/utils/correlation-to-covariance'),\n\tcovarianceToCorrelation: require('./lib/utils/covariance-to-correlation'),\n\tprojectObservation: require('./lib/utils/project-observation'),\n}, modelCollection);\n","const {matMul, transpose, add, invert, subtract: sub, identity: getIdentity} = require('simple-linalg');\nconst State = require('./state.js');\nconst checkMatrix = require('./utils/check-matrix.js');\n/**\n* @callback PreviousCorrectedCallback\n* @param {Object} opts\n* @param {Number} opts.index\n* @param {Number} opts.previousCorrected\n* @returns {Array.Array.<Number>>}\n*/\n\n/**\n* @callback PredictedCallback\n* @param {Object} opts\n* @param {Number} opts.index\n* @param {State} opts.predicted\n* @param {Observation} opts.observation\n* @returns {Array.Array.<Number>>}\n*/\n\n/**\n* @typedef {Object} ObservationConfig\n* @property {Number} dimension\n* @property {PredictedCallback} [fn=null] for extended kalman filter only, the non-linear state to observation function\n* @property {Array.Array.<Number>> | PreviousCorrectedCallback} stateProjection the matrix to transform state to observation (for EKF, the jacobian of the fn)\n* @property {Array.Array.<Number>> | PreviousCorrectedCallback} covariance the covariance of the observation noise\n*/\n\n/**\n* @typedef {Object} DynamicConfig\n* @property {Number} dimension dimension of the state vector\n* @property {PreviousCorrectedCallback} [constant=null] a function that returns the control parameter B_k*u_k of the kalman filter\n* @property {PreviousCorrectedCallback} [fn=null] for extended kalman filter only, the non-linear state-transition model\n* @property {Array.Array.<Number>> | PredictedCallback} transition the state-transition model (or for EKF the jacobian of the fn)\n* @property {Array.Array.<Number>> | PredictedCallback} covariance the covariance of the process noise\n*/\n\n/**\n* @typedef {Object} CoreConfig\n* @property {DynamicConfig} dynamic the system's dynamic model\n* @property {ObservationConfig} observation the system's observation model\n* @property {Object} [logger=defaultLogger] a Winston-like logger\n*/\nconst defaultLogger = {\n\tinfo: (...args) => console.log(...args),\n\tdebug() {},\n\twarn: (...args) => console.log(...args),\n\terror: (...args) => console.log(...args),\n};\n/**\n * @param {CoreConfig} options\n*/\nclass CoreKalmanFilter {\n\tconstructor(options) {\n\t\tconst {dynamic, observation, logger = defaultLogger} = options;\n\t\tthis.dynamic = dynamic;\n\t\tthis.observation = observation;\n\t\tthis.logger = logger;\n\t}\n\n\tgetValue(fn, options) {\n\t\treturn (typeof (fn) === 'function' ? fn(options) : fn);\n\t}\n\n\tgetInitState() {\n\t\tconst {mean: meanInit, covariance: covarianceInit, index: indexInit} = this.dynamic.init;\n\n\t\tconst initState = new State({\n\t\t\tmean: meanInit,\n\t\t\tcovariance: covarianceInit,\n\t\t\tindex: indexInit,\n\t\t});\n\t\tState.check(initState, {title: 'dynamic.init'});\n\t\treturn initState;\n\t}\n\n\t/**\n\tThis will return the predicted covariance of a given previousCorrected State, this will help us to build the asymptoticState.\n\t* @param {State} previousCorrected\n\t* @returns{Array.<Array.<Number>>}\n\t*/\n\n\tgetPredictedCovariance(options = {}) {\n\t\tlet {previousCorrected, index} = options;\n\t\tpreviousCorrected = previousCorrected || this.getInitState();\n\n\t\tconst getValueOptions = Object.assign({}, {previousCorrected, index}, options);\n\t\tconst transition = this.getValue(this.dynamic.transition, getValueOptions);\n\n\t\tcheckMatrix(transition, [this.dynamic.dimension, this.dynamic.dimension], 'dynamic.transition');\n\n\t\tconst transitionTransposed = transpose(transition);\n\t\tconst covarianceInter = matMul(transition, previousCorrected.covariance);\n\t\tconst covariancePrevious = matMul(covarianceInter, transitionTransposed);\n\t\tconst dynCov = this.getValue(this.dynamic.covariance, getValueOptions);\n\n\t\tconst covariance = add(\n\t\t\tdynCov,\n\t\t\tcovariancePrevious,\n\t\t);\n\t\tcheckMatrix(covariance, [this.dynamic.dimension, this.dynamic.dimension], 'predicted.covariance');\n\n\t\treturn covariance;\n\t}\n\n\tpredictMean(o) {\n\t\tconst mean = this.predictMeanWithoutControl(o);\n\t\tif (!this.dynamic.constant) {\n\t\t\treturn mean;\n\t\t}\n\n\t\tconst {opts} = o;\n\t\tconst control = this.dynamic.constant(opts);\n\t\tcheckMatrix(control, [this.dynamic.dimension, 1], 'dynamic.constant');\n\t\treturn add(mean, control);\n\t}\n\n\tpredictMeanWithoutControl({opts, transition}) {\n\t\tif (this.dynamic.fn) {\n\t\t\treturn this.dynamic.fn(opts);\n\t\t}\n\n\t\tconst {previousCorrected} = opts;\n\t\treturn matMul(transition, previousCorrected.mean);\n\t}\n\t/**\n\tThis will return the new prediction, relatively to the dynamic model chosen\n\t* @param {State} previousCorrected State relative to our dynamic model\n\t* @returns{State} predicted State\n\t*/\n\n\tpredict(options = {}) {\n\t\tlet {previousCorrected, index} = options;\n\t\tpreviousCorrected = previousCorrected || this.getInitState();\n\n\t\tif (typeof (index) !== 'number' && typeof (previousCorrected.index) === 'number') {\n\t\t\tindex = previousCorrected.index + 1;\n\t\t}\n\n\t\tState.check(previousCorrected, {dimension: this.dynamic.dimension});\n\t\tconst getValueOptions = Object.assign({}, options, {\n\t\t\tpreviousCorrected,\n\t\t\tindex,\n\t\t});\n\n\t\tconst transition = this.getValue(this.dynamic.transition, getValueOptions);\n\n\t\tconst mean = this.predictMean({transition, opts: getValueOptions});\n\n\t\tconst covariance = this.getPredictedCovariance(getValueOptions);\n\n\t\tconst predicted = new State({mean, covariance, index});\n\t\tthis.logger.debug('Prediction done', predicted);\n\t\tif (Number.isNaN(predicted.mean[0][0])) {\n\t\t\tthrow (new TypeError('nan'));\n\t\t}\n\n\t\treturn predicted;\n\t}\n\t/**\n\tThis will return the new correction, taking into account the prediction made\n\tand the observation of the sensor\n\t* @param {State} predicted the previous State\n\t* @returns{Array<Array>} kalmanGain\n\t*/\n\n\tgetGain(options) {\n\t\tlet {predicted, stateProjection} = options;\n\t\tconst getValueOptions = Object.assign({}, {index: predicted.index}, options);\n\t\tstateProjection = stateProjection || this.getValue(this.observation.stateProjection, getValueOptions);\n\t\tconst obsCovariance = this.getValue(this.observation.covariance, getValueOptions);\n\t\tcheckMatrix(obsCovariance, [this.observation.dimension, this.observation.dimension], 'observation.covariance');\n\t\tconst stateProjTransposed = transpose(stateProjection);\n\n\t\tcheckMatrix(stateProjection, [this.observation.dimension, this.dynamic.dimension], 'observation.stateProjection');\n\n\t\tconst noiselessInnovation = matMul(\n\t\t\tmatMul(stateProjection, predicted.covariance),\n\t\t\tstateProjTransposed,\n\t\t);\n\n\t\tconst innovationCovariance = add(noiselessInnovation, obsCovariance);\n\n\t\tconst optimalKalmanGain = matMul(\n\t\t\tmatMul(predicted.covariance, stateProjTransposed),\n\t\t\tinvert(innovationCovariance),\n\t\t);\n\n\t\treturn optimalKalmanGain;\n\t}\n\n\t/**\n\tThis will return the corrected covariance of a given predicted State, this will help us to build the asymptoticState.\n\t* @param {State} predicted the previous State\n\t* @returns{Array.<Array.<Number>>}\n\t*/\n\n\tgetCorrectedCovariance(options) {\n\t\tlet {predicted, optimalKalmanGain, stateProjection} = options;\n\t\tconst identity = getIdentity(predicted.covariance.length);\n\t\tif (!stateProjection) {\n\t\t\tconst getValueOptions = Object.assign({}, {index: predicted.index}, options);\n\t\t\tstateProjection = this.getValue(this.observation.stateProjection, getValueOptions);\n\t\t}\n\n\t\tif (!optimalKalmanGain) {\n\t\t\toptimalKalmanGain = this.getGain(Object.assign({stateProjection}, options));\n\t\t}\n\n\t\treturn matMul(\n\t\t\tsub(identity, matMul(optimalKalmanGain, stateProjection)),\n\t\t\tpredicted.covariance,\n\t\t);\n\t}\n\n\tgetPredictedObservation({opts, stateProjection}) {\n\t\tif (this.observation.fn) {\n\t\t\treturn this.observation.fn(opts);\n\t\t}\n\n\t\tconst {predicted} = opts;\n\t\treturn matMul(stateProjection, predicted.mean);\n\t}\n\n\t/**\n\tThis will return the new correction, taking into account the prediction made\n\tand the observation of the sensor\n\t* @param {State} predicted the previous State\n\t* @param {Array} observation the observation of the sensor\n\t* @returns{State} corrected State of the Kalman Filter\n\t*/\n\n\tcorrect(options) {\n\t\tconst {predicted, observation} = options;\n\t\tState.check(predicted, {dimension: this.dynamic.dimension});\n\t\tif (!observation) {\n\t\t\tthrow (new Error('no measure available'));\n\t\t}\n\n\t\tconst getValueOptions = Object.assign({}, {observation, predicted, index: predicted.index}, options);\n\t\tconst stateProjection = this.getValue(this.observation.stateProjection, getValueOptions);\n\n\t\tconst optimalKalmanGain = this.getGain(Object.assign({predicted, stateProjection}, options));\n\n\t\tconst innovation = sub(\n\t\t\tobservation,\n\t\t\tthis.getPredictedObservation({stateProjection, opts: getValueOptions}),\n\t\t);\n\n\t\tconst mean = add(\n\t\t\tpredicted.mean,\n\t\t\tmatMul(optimalKalmanGain, innovation),\n\t\t);\n\t\tif (Number.isNaN(mean[0][0])) {\n\t\t\tconsole.log({optimalKalmanGain, innovation, predicted});\n\t\t\tthrow (new TypeError('Mean is NaN after correction'));\n\t\t}\n\n\t\tconst covariance = this.getCorrectedCovariance(Object.assign({predicted, optimalKalmanGain, stateProjection}, options));\n\t\tconst corrected = new State({mean, covariance, index: predicted.index});\n\t\tthis.logger.debug('Correction done', corrected);\n\t\treturn corrected;\n\t}\n}\n\nmodule.exports = CoreKalmanFilter;\n","const {buildDynamic} = require('../model-collection');\n\n/**\n* @typedef {Object.<DynamicName, DynamicConfig>} PerNameConfigs\n*/\n/**\n* @typedef {Object} DynamicConfig\n* @param {Array.<Number>} obsIndexes\n* @param {Covariance} staticCovariance\n*/\n\n/**\n*Creates a dynamic model, considering the null in order to make the predictions\n* @param {Object} main\n* @param {Object.<String, DynamicConfig>} main.perName\n* @param {ObservationConfig} observation\n* @param {Array.<Array.<Number>>} opts.observedProjection\n* @returns {DynamicConfig}\n*/\nmodule.exports = function ({perName}, observation) {\n\tconst {observedProjection} = observation;\n\tconst observedDynamDimension = observedProjection[0].length;\n\n\tconst dynamicNames = Object.keys(perName);\n\n\tconst confs = {};\n\tlet nextDynamicDimension = observedDynamDimension;\n\tlet nextObservedDimension = 0;\n\tdynamicNames.forEach(k => {\n\t\tconst obsDynaIndexes = perName[k].obsDynaIndexes;\n\t\tif (typeof (perName[k].name) === 'string' && perName[k].name !== k) {\n\t\t\tthrow (new Error(`${perName[k].name} and \"${k}\" should match`));\n\t\t}\n\n\t\tperName[k].name = k;\n\n\t\tconst {dimension, transition, covariance, init} = buildDynamic(perName[k], observation);\n\n\t\tconst dynamicIndexes = [];\n\t\tfor (let i = 0; i < dimension; i++) {\n\t\t\tconst isObserved = (i < obsDynaIndexes.length);\n\t\t\tlet newIndex;\n\t\t\tif (isObserved) {\n\t\t\t\tnewIndex = nextObservedDimension;\n\t\t\t\tif (newIndex !== obsDynaIndexes[i]) {\n\t\t\t\t\tthrow (new Error('thsoe should match'));\n\t\t\t\t}\n\n\t\t\t\tnextObservedDimension++;\n\t\t\t} else {\n\t\t\t\tnewIndex = nextDynamicDimension;\n\t\t\t\tnextDynamicDimension++;\n\t\t\t}\n\n\t\t\tdynamicIndexes.push(newIndex);\n\t\t}\n\n\t\tconfs[k] = {\n\t\t\tdynamicIndexes,\n\t\t\ttransition,\n\t\t\tdimension,\n\t\t\tcovariance,\n\t\t\tinit,\n\t\t};\n\t});\n\n\tconst totalDimension = dynamicNames.map(k => confs[k].dimension).reduce((a, b) => a + b, 0);\n\n\tif (nextDynamicDimension !== totalDimension) {\n\t\tthrow (new Error('miscalculation of transition'));\n\t}\n\n\tconst init = {\n\t\tindex: -1,\n\t\tmean: new Array(totalDimension),\n\t\tcovariance: new Array(totalDimension).fill(0).map(() => new Array(totalDimension).fill(0)),\n\t};\n\tdynamicNames.forEach(k => {\n\t\tconst {\n\t\t\tdynamicIndexes,\n\t\t\tinit: localInit,\n\t\t} = confs[k];\n\t\tif (typeof (localInit) !== 'object') {\n\t\t\tthrow new TypeError('Init is mandatory');\n\t\t}\n\n\t\tdynamicIndexes.forEach((c1, i1) => dynamicIndexes.forEach((c2, i2) => {\n\t\t\tinit.covariance[c1][c2] = localInit.covariance[i1][i2];\n\t\t}));\n\t\tdynamicIndexes.forEach((c1, i1) => {\n\t\t\tinit.mean[c1] = localInit.mean[i1];\n\t\t});\n\t});\n\treturn {\n\t\tdimension: totalDimension,\n\t\tinit,\n\t\ttransition(options) {\n\t\t\tconst {previousCorrected} = options;\n\t\t\tconst resultTransition = new Array(totalDimension).fill().map(() => new Array(totalDimension).fill(0));\n\n\t\t\tdynamicNames.forEach(k => {\n\t\t\t\tconst {\n\t\t\t\t\tdynamicIndexes,\n\t\t\t\t\ttransition,\n\t\t\t\t} = confs[k];\n\n\t\t\t\tconst options2 = Object.assign({}, options, {previousCorrected: previousCorrected.subState(dynamicIndexes)});\n\t\t\t\tconst trans = transition(options2);\n\t\t\t\tdynamicIndexes.forEach((c1, i1) => dynamicIndexes.forEach((c2, i2) => {\n\t\t\t\t\tresultTransition[c1][c2] = trans[i1][i2];\n\t\t\t\t}));\n\t\t\t});\n\t\t\treturn resultTransition;\n\t\t},\n\t\tcovariance(options) {\n\t\t\tconst {previousCorrected} = options;\n\t\t\tconst resultCovariance = new Array(totalDimension).fill().map(() => new Array(totalDimension).fill(0));\n\n\t\t\tdynamicNames.forEach(k => {\n\t\t\t\tconst {\n\t\t\t\t\tdynamicIndexes,\n\t\t\t\t\tcovariance,\n\t\t\t\t} = confs[k];\n\n\t\t\t\tconst options2 = Object.assign({}, options, {previousCorrected: previousCorrected.subState(dynamicIndexes)});\n\n\t\t\t\tconst cov = covariance(options2);\n\t\t\t\t// Console.log('dynamic.composition',k, cov, dynamicIndexes)\n\t\t\t\tdynamicIndexes.forEach((c1, i1) => dynamicIndexes.forEach((c2, i2) => {\n\t\t\t\t\tresultCovariance[c1][c2] = cov[i1][i2];\n\t\t\t\t}));\n\t\t\t});\n\t\t\treturn resultCovariance;\n\t\t},\n\t};\n};\n","const {identity} = require('simple-linalg');\n\n/**\n*Creates a dynamic model, following constant acceleration model with respect with the dimensions provided in the observation parameters\n* @param {DynamicConfig} dynamic\n* @param {ObservationConfig} observation\n* @returns {DynamicConfig}\n*/\n\nmodule.exports = function (dynamic, observation) {\n\tconst timeStep = dynamic.timeStep || 1;\n\tconst {observedProjection} = observation;\n\tconst {stateProjection} = observation;\n\tconst observationDimension = observation.dimension;\n\tlet dimension;\n\n\tif (stateProjection && Number.isInteger(stateProjection[0].length / 3)) {\n\t\tdimension = observation.stateProjection[0].length;\n\t} else if (observedProjection) {\n\t\tdimension = observedProjection[0].length * 3;\n\t} else if (observationDimension) {\n\t\tdimension = observationDimension * 3;\n\t} else {\n\t\tthrow (new Error('observedProjection or stateProjection should be defined in observation in order to use constant-speed filter'));\n\t}\n\n\tconst baseDimension = dimension / 3;\n\t// We construct the transition and covariance matrices\n\tconst transition = identity(dimension);\n\tfor (let i = 0; i < baseDimension; i++) {\n\t\ttransition[i][i + baseDimension] = timeStep;\n\t\ttransition[i][i + (2 * baseDimension)] = 0.5 * (timeStep ** 2);\n\t\ttransition[i + baseDimension][i + (2 * baseDimension)] = timeStep;\n\t}\n\n\tconst arrayCovariance = new Array(baseDimension).fill(1)\n\t\t.concat(new Array(baseDimension).fill(timeStep * timeStep))\n\t\t.concat(new Array(baseDimension).fill(timeStep ** 4));\n\tconst covariance = dynamic.covariance || arrayCovariance;\n\treturn Object.assign({}, dynamic, {dimension, transition, covariance});\n};\n","const {identity, diag} = require('simple-linalg');\n\nconst huge = 1e6;\n\n/**\n*Creates a dynamic model, considering the null in order to make the predictions\n* @param {Array.<Array.<Number>>} staticCovariance generated with moving average\n* @param {Number} observationDimension\n* @returns {DynamicConfig}\n*/\nconst constantPositionWithNull = function ({staticCovariance, obsDynaIndexes, init}) {\n\tconst dimension = obsDynaIndexes.length;\n\tif (!init) {\n\t\tinit = {\n\t\t\tmean: new Array(obsDynaIndexes.length).fill(0).map(() => [0]),\n\t\t\tcovariance: diag(new Array(obsDynaIndexes.length).fill(huge)),\n\t\t\tindex: -1,\n\t\t};\n\t}\n\n\tif (staticCovariance && staticCovariance.length !== dimension) {\n\t\tthrow (new Error('staticCovariance has wrong size'));\n\t}\n\n\treturn {\n\t\tdimension,\n\t\ttransition() {\n\t\t\treturn identity(dimension);\n\t\t},\n\t\tcovariance({previousCorrected, index}) {\n\t\t\tconst diffBetweenIndexes = index - previousCorrected.index;\n\t\t\tif (staticCovariance) {\n\t\t\t\treturn staticCovariance.map(row => row.map(element => element * diffBetweenIndexes));\n\t\t\t}\n\n\t\t\treturn identity(dimension);\n\t\t},\n\t\tinit,\n\t};\n};\n\nmodule.exports = constantPositionWithNull;\n","const {identity} = require('simple-linalg');\n/**\n*Creates a dynamic model, following constant position model with respect with the dimensions provided in the observation parameters\n* @param {DynamicConfig} dynamic\n* @param {ObservationConfig} observation\n* @returns {DynamicConfig}\n*/\n\nmodule.exports = function (dynamic, observation) {\n\tlet {dimension} = dynamic;\n\tconst observationDimension = observation.dimension;\n\tconst {observedProjection} = observation;\n\tconst {stateProjection} = observation;\n\tlet {covariance} = dynamic;\n\n\tif (!dynamic.dimension) {\n\t\tif (observationDimension) {\n\t\t\tdimension = observationDimension;\n\t\t} else if (observedProjection) {\n\t\t\tdimension = observedProjection[0].length;\n\t\t} else if (stateProjection) {\n\t\t\tdimension = stateProjection[0].length;\n\t\t}\n\t}\n\n\tconst transition = identity(dimension);\n\tcovariance = covariance || identity(dimension);\n\treturn Object.assign({}, dynamic, {dimension, transition, covariance});\n};\n","const {diag} = require('simple-linalg');\n\n/**\n*Creates a dynamic model, considering the null in order to make the predictions\n* @param {Array.<Number>} staticCovariance\n* @param {ObservationConfig} observation\n* @returns {DynamicConfig}\n*/\nconst constantSpeedDynamic = function ({staticCovariance, avSpeed, center}, observation) {\n\tconst observationDimension = observation.observedProjection[0].length;\n\n\tconst dimension = 2 * observationDimension;\n\n\tif ((center) === undefined) {\n\t\tthrow (new TypeError('Center must be defined'));\n\t}\n\n\tif (center.length !== observationDimension) {\n\t\tthrow (new TypeError(`Center size should be ${observationDimension}`));\n\t}\n\n\tif (avSpeed.length !== observationDimension) {\n\t\tthrow (new TypeError(`avSpeed size should be ${observationDimension}`));\n\t}\n\n\tconst initCov = diag(center.map(c => c * c / 3).concat(avSpeed.map(c => c * c / 3)));\n\n\tconst init = {\n\t\tmean: center.map(c => [c]).concat(center.map(() => [0])),\n\t\tcovariance: initCov,\n\t\tindex: -1,\n\t};\n\n\tconst transition = ({getTime, index, previousCorrected}) => {\n\t\tconst dT = getTime(index) - getTime(previousCorrected.index);\n\t\tif (typeof (dT) !== 'number' || Number.isNaN(dT)) {\n\t\t\tthrow (new TypeError(`dT (${dT}) should be a number`));\n\t\t}\n\t\t// Example is :\n\t\t// [\n\t\t// \t[1, 0, dT, 0],\n\t\t// \t[0, 1, 0, dT],\n\t\t// \t[0, 0, 1, 0],\n\t\t// \t[0, 0, 0, 1]\n\t\t// ];\n\t\t// constant speed usual matrix\n\n\t\t// create identity matrix\n\t\tconst mat = diag(center.map(() => 1).concat(center.map(() => 1)));\n\t\t// Then add dT\n\t\tfor (let i = 0; i < observationDimension; i++) {\n\t\t\tmat[i][observationDimension + i] = dT;\n\t\t}\n\n\t\tif (Number.isNaN(mat[0][2])) {\n\t\t\tthrow (new TypeError('nan mat'));\n\t\t}\n\n\t\treturn mat;\n\t};\n\n\tconst covariance = ({index, previousCorrected, getTime}) => {\n\t\tconst dT = getTime(index) - getTime(previousCorrected.index);\n\n\t\tif (typeof (dT) !== 'number') {\n\t\t\tthrow (new TypeError(`dT (${dT}) should be a number`));\n\t\t}\n\n\t\t// State is (x, y, vx, vy)\n\t\tconst sqrt = Math.sqrt(dT);\n\t\tif (Number.isNaN(sqrt)) {\n\t\t\tconsole.log({lastPreviousIndex: previousCorrected.index, index});\n\t\t\tconsole.log(dT, previousCorrected.index, index, getTime(index), getTime(previousCorrected.index));\n\t\t\tthrow (new Error('Sqrt(dT) is NaN'));\n\t\t}\n\n\t\treturn diag(staticCovariance.map(v => v * sqrt));\n\t};\n\n\treturn {\n\t\tinit,\n\t\tdimension,\n\t\ttransition,\n\t\tcovariance,\n\t};\n};\n\nmodule.exports = constantSpeedDynamic;\n","const {identity, diag} = require('simple-linalg');\n\nconst nullModels = {\n\tlinear(a) {\n\t\treturn a;\n\t},\n\tone() {\n\t\treturn 1;\n\t},\n\tsquare(a) {\n\t\treturn a * a;\n\t},\n};\nconst huge = 1e6;\n/**\n*Creates a dynamic model, considering the null in order to make the predictions\n* @param {Array.<Array.<Number>>} staticCovariance generated with moving average\n* @param {ObservationConfig} observation\n* @returns {DynamicConfig}\n*/\nconst constantSpeedWithNull = function ({staticCovariance, obsDynaIndexes, nullGapModel = null, init}, observation) {\n\tif (!obsDynaIndexes) {\n\t\tconst l = observation.observedProjection[0].length;\n\t\tobsDynaIndexes = new Array(l).fill(0).map((_, i) => i);\n\t}\n\n\tif (staticCovariance && Number.isNaN(staticCovariance[0][0])) {\n\t\tthrow (new Error('NaN staticCovariance'));\n\t}\n\n\tconst dimension = 2 * obsDynaIndexes.length;\n\tif (!init) {\n\t\tinit = {\n\t\t\tmean: new Array(obsDynaIndexes.length * 2).fill(0).map(() => [0]),\n\t\t\tcovariance: diag(new Array(obsDynaIndexes.length * 2).fill(huge)),\n\t\t\tindex: -1,\n\t\t};\n\t}\n\n\tif (!nullGapModel) {\n\t\tnullGapModel = new Array(dimension).fill(0).map(() => 'linear');\n\t}\n\n\treturn {\n\t\tdimension,\n\t\tinit,\n\t\ttransition({previousCorrected, index}) {\n\t\t\tconst diffBetweenIndexes = index - previousCorrected.index;\n\n\t\t\tif (Number.isNaN(diffBetweenIndexes)) {\n\t\t\t\tthrow (new TypeError('diffBetweenIndexes is NaN'));\n\t\t\t}\n\n\t\t\tconst emptyTransition = new Array(dimension).fill(new Array(dimension).fill());\n\n\t\t\tconst observationDimension = dimension / 2;\n\t\t\tconst transition = emptyTransition.map((row, rowId) => row.map((col, colId) => {\n\t\t\t\tif (rowId === colId) {\n\t\t\t\t\treturn 1;\n\t\t\t\t}\n\n\t\t\t\tif (rowId + observationDimension === colId) {\n\t\t\t\t\tif (index === 0) {\n\t\t\t\t\t\treturn 0;\n\t\t\t\t\t}\n\n\t\t\t\t\treturn diffBetweenIndexes;\n\t\t\t\t}\n\n\t\t\t\treturn 0;\n\t\t\t}));\n\t\t\treturn transition;\n\t\t},\n\t\tcovariance({previousCorrected, index}) {\n\t\t\tconst diffBetweenIndexes = index - previousCorrected.index;\n\t\t\tif (staticCovariance) {\n\t\t\t\tconst covariance = staticCovariance.map((row, rowIndex) => row.map((element, colIndex) => {\n\t\t\t\t\tconst factor = Math.sqrt(nullModels[nullGapModel[rowIndex]](diffBetweenIndexes) * nullModels[nullGapModel[colIndex]](diffBetweenIndexes));\n\t\t\t\t\treturn element * factor;\n\t\t\t\t}));\n\n\t\t\t\treturn covariance;\n\t\t\t}\n\n\t\t\treturn identity(dimension);\n\t\t},\n\t};\n};\n\nmodule.exports = constantSpeedWithNull;\n","const {identity} = require('simple-linalg');\n\n/**\n*Creates a dynamic model, following constant position model with respect with the dimensions provided in the observation parameters\n* @param {DynamicConfig} dynamic\n* @param {ObservationConfig} observation\n* @returns {DynamicConfig}\n*/\n\nmodule.exports = function (dynamic, observation) {\n\tconst timeStep = dynamic.timeStep || 1;\n\tconst {observedProjection} = observation;\n\tconst {stateProjection} = observation;\n\tconst observationDimension = observation.dimension;\n\tlet dimension;\n\n\tif (stateProjection && Number.isInteger(stateProjection[0].length / 2)) {\n\t\tdimension = observation.stateProjection[0].length;\n\t} else if (observedProjection) {\n\t\tdimension = observedProjection[0].length * 2;\n\t} else if (observationDimension) {\n\t\tdimension = observationDimension * 2;\n\t} else {\n\t\tthrow (new Error('observedProjection or stateProjection should be defined in observation in order to use constant-speed filter'));\n\t}\n\n\tconst baseDimension = dimension / 2;\n\t// We construct the transition and covariance matrices\n\tconst transition = identity(dimension);\n\tfor (let i = 0; i < baseDimension; i++) {\n\t\ttransition[i][i + baseDimension] = timeStep;\n\t}\n\n\tconst arrayCovariance = new Array(baseDimension).fill(1).concat(new Array(baseDimension).fill(timeStep * timeStep));\n\tconst covariance = dynamic.covariance || arrayCovariance;\n\treturn Object.assign({}, dynamic, {dimension, transition, covariance});\n};\n","module.exports = {\n\t'constant-position': require('./constant-position.js'),\n\t'constant-speed': require('./constant-speed.js'),\n\t'constant-acceleration': require('./constant-acceleration.js'),\n\tcomposition: require('./composition.js'),\n\t'constant-position-with-null': require('./constant-position-with-null.js'),\n\t'constant-speed-with-null': require('./constant-speed-with-null.js'),\n\t'constant-speed-dynamic': require('./constant-speed-dynamic.js'),\n\t'shortterm-constant-speed': require('./shortterm-constant-speed.js'),\n};\n","const {elemWise, diag} = require('simple-linalg');\nconst constantSpeedDynamic = require('./constant-speed-dynamic');\n\nconst safeDiv = function (a, b) {\n\tif (a === 0) {\n\t\treturn 0;\n\t}\n\n\tif (b === 0) {\n\t\treturn 1;\n\t}\n\n\treturn a / b;\n};\n\n/**\n* This model is based on the constant speed model\n* The constant speed model creates problems when dT >> fps (the track is lost)\n* then the expected position can be very far from the center of the field\n* to solve that, we use a model with 2 more hidden variable that are always center of the field\n* When dT << typicalTime the model acts exactly as a constant speed model\n* When dT >> typicalTime the model is a constant [x,y] = center model, sigma = defaultVariance\n* @param {Object} options\n* @param {ObservationConfig} observation\n* @param {Number} [options.typicalTime=10]\n* @returns {DynamicConfig}\n*/\nmodule.exports = function (options, observation) {\n\tconst {typicalTimes} = options;\n\n\tif (!Array.isArray(typicalTimes)) {\n\t\tthrow (new TypeError('typicalTimes must be defined'));\n\t}\n\n\tconst constantSpeed = constantSpeedDynamic(options, observation);\n\tconst {dimension, init} = constantSpeed;\n\n\tif (typicalTimes.length !== dimension) {\n\t\tthrow (new TypeError(`typicalTimes (${typicalTimes.length}) length is not as expected (${dimension})`));\n\t}\n\n\tconst mixMatrix = function ({\n\t\tratios,\n\t\taMat,\n\t\tbMat,\n\t}) {\n\t\treturn elemWise([aMat, bMat], ([m, d], rowIndex, colIndex) => {\n\t\t\tconst ratio = rowIndex === colIndex ? ratios[rowIndex] : (ratios[rowIndex] + ratios[colIndex]) / 2;\n\n\t\t\treturn (ratio * m) + ((1 - ratio) * d);\n\t\t});\n\t};\n\n\treturn {\n\t\tdimension,\n\t\tinit,\n\t\ttransition(options) {\n\t\t\tconst aMat = constantSpeed.transition(options);\n\n\t\t\tconst {getTime, index, previousCorrected} = options;\n\t\t\tconst dT = getTime(index) - getTime(previousCorrected.index);\n\n\t\t\tconst ratios = typicalTimes.map(t => Math.exp(-1 * dT / t));\n\n\t\t\t// 'back to init' matrix\n\t\t\tconst bMat = diag(\n\t\t\t\telemWise([init.mean, previousCorrected.mean], ([m, d]) => safeDiv(m, d))\n\t\t\t\t// Flatten cause this is a Nx1 matrix -> N array\n\t\t\t\t\t.reduce((a, b) => a.concat(b)),\n\t\t\t);\n\n\t\t\treturn mixMatrix({ratios, aMat, bMat});\n\t\t},\n\t\tcovariance(options, observation) {\n\t\t\tconst {getTime, index, previousCorrected} = options;\n\n\t\t\tconst dT = getTime(index) - getTime(previousCorrected.index);\n\t\t\t// State is (x, y, vx, vy)\n\t\t\tconst ratios = typicalTimes.map(t => Math.exp(-1 * dT / t));\n\t\t\tconst aMat = constantSpeed.covariance(options, observation);\n\t\t\treturn mixMatrix({ratios, aMat, bMat: init.covariance});\n\t\t},\n\t};\n};\n","\nconst {frobenius: distanceMat} = require('simple-linalg');\nconst arrayToMatrix = require('../lib/utils/array-to-matrix.js');\nconst setDimensions = require('../lib/setup/set-dimensions.js');\nconst checkDimensions = require('../lib/setup/check-dimensions.js');\nconst buildStateProjection = require('../lib/setup/build-state-projection.js');\nconst extendDynamicInit = require('../lib/setup/extend-dynamic-init.js');\nconst toFunction = require('../lib/utils/to-function.js');\nconst deepAssign = require('../lib/utils/deep-assign.js');\nconst polymorphMatrix = require('../lib/utils/polymorph-matrix.js');\nconst State = require('./state.js');\nconst modelCollection = require('./model-collection.js');\nconst CoreKalmanFilter = require('./core-kalman-filter.js');\n\n/**\n * @typedef {String} DynamicNonObjectConfig\n */\n/**\n * @typedef {DynamicConfig} DynamicObjectConfig\n * @property {String} name\n */\n/**\n * @param {DynamicNonObjectConfig} dynamic\n * @returns {DynamicObjectConfig}\n */\n\nconst buildDefaultDynamic = function (dynamic) {\n\tif (typeof (dynamic) === 'string') {\n\t\treturn {name: dynamic};\n\t}\n\n\treturn {name: 'constant-position'};\n};\n\n/**\n * @typedef {String | Number} ObservationNonObjectConfig\n */\n/**\n * @typedef {ObservationConfig} ObservationObjectConfig\n * @property {String} name\n */\n/**\n * @param {ObservationNonObjectConfig} observation\n * @returns {ObservationObjectConfig}\n */\nconst buildDefaultObservation = function (observation) {\n\tif (typeof (observation) === 'number') {\n\t\treturn {name: 'sensor', sensorDimension: observation};\n\t}\n\n\tif (typeof (observation) === 'string') {\n\t\treturn {name: observation};\n\t}\n\n\treturn {name: 'sensor'};\n};\n/**\n*This function fills the given options by successively checking if it uses a registered model,\n* it builds and checks the dynamic and observation dimensions, build the stateProjection if only observedProjection\n*is given, and initialize dynamic.init\n*@param {DynamicObjectConfig | DynamicNonObjectConfig} options.dynamic\n*@param {ObservationObjectConfig | ObservationNonObjectConfig} options.observation\n* @returns {CoreConfig}\n*/\n\nconst setupModelsParameters = function ({observation, dynamic}) {\n\tif (typeof (observation) !== 'object' || observation === null) {\n\t\tobservation = buildDefaultObservation(observation);\n\t}\n\n\tif (typeof (dynamic) !== 'object' || dynamic === null) {\n\t\tdynamic = buildDefaultDynamic(dynamic, observation);\n\t}\n\n\tif (typeof (observation.name) === 'string') {\n\t\tobservation = modelCollection.buildObservation(observation);\n\t}\n\n\tif (typeof (dynamic.name) === 'string') {\n\t\tdynamic = modelCollection.buildDynamic(dynamic, observation);\n\t}\n\n\tconst withDimensionOptions = setDimensions({observation, dynamic});\n\tconst checkedDimensionOptions = checkDimensions(withDimensionOptions);\n\tconst buildStateProjectionOptions = buildStateProjection(checkedDimensionOptions);\n\treturn extendDynamicInit(buildStateProjectionOptions);\n};\n\n/**\n* @typedef {Object} ModelsParameters\n* @property {DynamicObjectConfig} dynamic\n* @property {ObservationObjectConfig} observation\n*/\n\n/**\n* Returns the corresponding model without arrays as values but only functions\n* @param {ModelsParameters} modelToBeChanged\n* @returns {CoreConfig} model with respect of the Core Kalman Filter properties\n*/\nconst modelsParametersToCoreOptions = function (modelToBeChanged) {\n\tconst {observation, dynamic} = modelToBeChanged;\n\treturn deepAssign(modelToBeChanged, {\n\t\tobservation: {\n\t\t\tstateProjection: toFunction(polymorphMatrix(observation.stateProjection), {label: 'observation.stateProjection'}),\n\t\t\tcovariance: toFunction(polymorphMatrix(observation.covariance, {dimension: observation.dimension}), {label: 'observation.covariance'}),\n\t\t},\n\t\tdynamic: {\n\t\t\ttransition: toFunction(polymorphMatrix(dynamic.transition), {label: 'dynamic.transition'}),\n\t\t\tcovariance: toFunction(polymorphMatrix(dynamic.covariance, {dimension: dynamic.dimension}), {label: 'dynamic.covariance'}),\n\t\t},\n\t});\n};\n\nclass KalmanFilter extends CoreKalmanFilter {\n\t/**\n\t* @typedef {Object} Config\n\t* @property {DynamicObjectConfig | DynamicNonObjectConfig} dynamic\n\t* @property {ObservationObjectConfig | ObservationNonObjectConfig} observation\n\t*/\n\t/**\n\t* @param {Config} options\n\t*/\n\tconstructor(options = {}) {\n\t\tconst modelsParameters = setupModelsParameters(options);\n\t\tconst coreOptions = modelsParametersToCoreOptions(modelsParameters);\n\n\t\tsuper(Object.assign({}, options, coreOptions));\n\t}\n\n\tcorrect(options) {\n\t\tconst coreObservation = arrayToMatrix({observation: options.observation, dimension: this.observation.dimension});\n\t\treturn super.correct(Object.assign({}, options, {observation: coreObservation}));\n\t}\n\n\t/**\n\t*Performs the prediction and the correction steps\n\t*@param {State} previousCorrected\n\t*@param {<Array.<Number>>} observation\n\t*@returns {Array.<Number>} the mean of the corrections\n\t*/\n\n\tfilter(options) {\n\t\tconst predicted = super.predict(options);\n\t\treturn this.correct(Object.assign({}, options, {predicted}));\n\t}\n\n\t/**\n*Filters all the observations\n*@param {Array.<Array.<Number>>} observations\n*@returns {Array.<Array.<Number>>} the mean of the corrections\n*/\n\tfilterAll(observations) {\n\t\tlet previousCorrected = this.getInitState();\n\t\tconst results = [];\n\t\tfor (const observation of observations) {\n\t\t\tconst predicted = this.predict({previousCorrected});\n\t\t\tpreviousCorrected = this.correct({\n\t\t\t\tpredicted,\n\t\t\t\tobservation,\n\t\t\t});\n\t\t\tresults.push(previousCorrected.mean.map(m => m[0]));\n\t\t}\n\n\t\treturn results;\n\t}\n\n\t/**\n\t* Returns an estimation of the asymptotic state covariance as explained in https://en.wikipedia.org/wiki/Kalman_filter#Asymptotic_form\n\t* in practice this can be used as a init.covariance value but is very costful calculation (that's why this is not made by default)\n\t* @param {Number} [limitIterations=1e2] max number of iterations\n\t* @param {Number} [tolerance=1e-6] returns when the last values differences are less than tolerance\n\t* @return {Array.<Array.<Number>>} covariance\n\t*/\n\tasymptoticStateCovariance({limitIterations = 1e2, tolerance = 1e-6} = {}) {\n\t\tlet previousCorrected = super.getInitState();\n\t\tlet predicted;\n\t\tconst results = [];\n\t\tfor (let i = 0; i < limitIterations; i++) {\n\t\t\t// We create a fake mean that will not be used in order to keep coherence\n\t\t\tpredicted = new State({\n\t\t\t\tmean: null,\n\t\t\t\tcovariance: super.getPredictedCovariance({previousCorrected}),\n\t\t\t});\n\t\t\tpreviousCorrected = new State({\n\t\t\t\tmean: null,\n\t\t\t\tcovariance: super.getCorrectedCovariance({predicted}),\n\t\t\t});\n\t\t\tresults.push(previousCorrected.covariance);\n\t\t\tif (distanceMat(previousCorrected.covariance, results[i - 1]) < tolerance) {\n\t\t\t\treturn results[i];\n\t\t\t}\n\t\t}\n\n\t\tthrow (new Error('The state covariance does not converge asymptotically'));\n\t}\n\n\t/**\n\t* Returns an estimation of the asymptotic gain, as explained in https://en.wikipedia.org/wiki/Kalman_filter#Asymptotic_form\n\t* @param {Number} [tolerance=1e-6] returns when the last values differences are less than tolerance\n\t* @return {Array.<Array.<Number>>} gain\n\t*/\n\tasymptoticGain({tolerance = 1e-6} = {}) {\n\t\tconst covariance = this.asymptoticStateCovariance({tolerance});\n\n\t\tconst asymptoticState = new State({\n\t\t\t// We create a fake mean that will not be used in order to keep coherence\n\t\t\tmean: Array.from({length: covariance.length}).fill(0).map(() => [0]),\n\t\t\tcovariance,\n\t\t});\n\n\t\treturn super.getGain({predicted: asymptoticState});\n\t}\n}\n\nmodule.exports = KalmanFilter;\n","\nconst registeredObservationModels = {};\nconst registeredDynamicModels = {};\n\nmodule.exports = {\n\t/**\n\t* Enables to register observation model and store it\n\t* @param {String} name\n\t* @callback fn the function corresponding to the desired model\n\t*/\n\n\tregisterObservation(name, fn) {\n\t\tregisteredObservationModels[name] = fn;\n\t},\n\t/**\n\t* Enables to register dynamic model and store it\n\t* @param {String} name\n\t* @callback fn the function corresponding to the desired model\n\t*/\n\n\tregisterDynamic(name, fn) {\n\t\tregisteredDynamicModels[name] = fn;\n\t},\n\t/**\n\t* Build a model given an observation configuration\n\t* @param {ObservationConfig} observation\n\t* @returns {ObservationConfig} the configuration with respect to the model\n\t*/\n\tbuildObservation(observation) {\n\t\tif (typeof (registeredObservationModels[observation.name]) !== 'function') {\n\t\t\tthrow (new TypeError(`The provided observation model name (${observation.name}) is not registered`));\n\t\t}\n\n\t\treturn registeredObservationModels[observation.name](observation);\n\t},\n\t/**\n\t* Build a model given dynamic and observation configurations\n\t* @param {DynamicConfig} dynamic\n\t* @param {ObservationConfig} observation\n\t* @returns {DynamicConfig} the dynamic configuration with respect to the model\n\t*/\n\n\tbuildDynamic(dynamic, observation) {\n\t\tif (typeof (registeredDynamicModels[dynamic.name]) !== 'function') {\n\t\t\tthrow (new TypeError(`The provided dynamic model (${dynamic.name}) name is not registered`));\n\t\t}\n\n\t\treturn registeredDynamicModels[dynamic.name](dynamic, observation);\n\t},\n};\n","module.exports = {\n\tsensor: require('./sensor.js'),\n\t'sensor-local-variance': require('./sensor-local-variance'),\n\t'sensor-projected': require('./sensor-projected'),\n};\n","const {identity} = require('simple-linalg');\nconst {buildObservation} = require('../model-collection');\n/**\n* @param {Object} options\n* @param {Number} options.sensorDimension\n* @param {CovarianceParam} options.sensorCovariance\n* @param {Number} options.nSensors\n* @returns {ObservationConfig}\n*/\n\nconst nullableSensor = function (options) {\n\tconst {dimension, observedProjection, covariance: baseCovariance} = buildObservation(Object.assign({}, options, {name: 'sensor'}));\n\n\treturn {\n\t\tdimension,\n\t\tobservedProjection,\n\t\tcovariance(o) {\n\t\t\tconst covariance = identity(dimension);\n\t\t\tconst {variance} = o;\n\n\t\t\tvariance.forEach((v, i) => {\n\t\t\t\tcovariance[i][i] = v * baseCovariance[i][i];\n\t\t\t});\n\n\t\t\treturn covariance;\n\t\t},\n\t};\n};\n\nmodule.exports = nullableSensor;\n\n","const {identity, matPermutation} = require('simple-linalg');\nconst correlationToCovariance = require('../utils/correlation-to-covariance');\nconst covarianceToCorrelation = require('../utils/covariance-to-correlation');\n\n/**\n*Creates an observation model with a observedProjection corresponding to\n* @param {DynamicConfig} dynamic\n* @param {ObservationConfig} observation\n* @returns {DynamicConfig}\n*/\n\nconst sensorProjected = function ({selectedCovariance, totalDimension, obsIndexes, selectedStateProjection}) {\n\tif (!selectedStateProjection) {\n\t\tselectedStateProjection = new Array(obsIndexes.length).fill(0).map(() => new Array(obsIndexes.length).fill(0));\n\t\tobsIndexes.forEach((index1, i1) => {\n\t\t\tselectedStateProjection[i1][i1] = 1;\n\t\t});\n\t} else if (selectedStateProjection.length !== obsIndexes.length) {\n\t\tthrow (new Error(`[Sensor-projected] Shape mismatch between ${selectedStateProjection.length} and ${obsIndexes.length}`));\n\t}\n\n\tconst baseCovariance = identity(totalDimension);\n\tobsIndexes.forEach((index1, i1) => {\n\t\tif (selectedCovariance) {\n\t\t\tobsIndexes.forEach((index2, i2) => {\n\t\t\t\tbaseCovariance[index1][index2] = selectedCovariance[i1][i2];\n\t\t\t});\n\t\t}\n\t});\n\tconst {correlation: baseCorrelation, variance: baseVariance} = covarianceToCorrelation(baseCovariance);\n\n\tconst dynaDimension = selectedStateProjection[0].length;\n\n\tif (selectedStateProjection.length !== obsIndexes.length) {\n\t\tthrow (new Error(`shape mismatch (${selectedStateProjection.length} vs ${obsIndexes.length})`));\n\t}\n\n\tconst observedProjection = matPermutation({\n\t\toutputSize: [totalDimension, dynaDimension],\n\t\tcolIndexes: selectedStateProjection[0].map((_, i) => i),\n\t\trowIndexes: obsIndexes,\n\t\tmatrix: selectedStateProjection,\n\t});\n\n\treturn {\n\t\tdimension: totalDimension,\n\t\tobservedProjection,\n\t\tcovariance(o) {\n\t\t\tconst {variance} = o;\n\t\t\tif (!variance) {\n\t\t\t\treturn baseCovariance;\n\t\t\t}\n\n\t\t\tif (variance.length !== baseCovariance.length) {\n\t\t\t\tthrow (new Error('variance is difference size from baseCovariance'));\n\t\t\t}\n\n\t\t\tconst result = correlationToCovariance({correlation: baseCorrelation, variance: baseVariance.map((b, i) => variance[i] * b)});\n\n\t\t\treturn result;\n\t\t},\n\t};\n};\n\nmodule.exports = sensorProjected;\n","const {identity} = require('simple-linalg');\nconst polymorphMatrix = require('../utils/polymorph-matrix.js');\nconst checkMatrix = require('../utils/check-matrix.js');\n\n/**\n* @param {Number} sensorDimension\n* @param {CovarianceParam} sensorCovariance\n* @param {Number} nSensors\n* @returns {ObservationConfig}\n*/\n\nconst copy = mat => mat.map(a => a.concat());\n\nmodule.exports = function (options) {\n\tconst {sensorDimension = 1, sensorCovariance = 1, nSensors = 1} = options;\n\tconst sensorCovarianceFormatted = polymorphMatrix(sensorCovariance, {dimension: sensorDimension});\n\tcheckMatrix(sensorCovarianceFormatted, [sensorDimension, sensorDimension], 'observation.sensorCovariance');\n\tconst oneSensorObservedProjection = identity(sensorDimension);\n\tlet concatenatedObservedProjection = [];\n\tconst dimension = sensorDimension * nSensors;\n\tconst concatenatedCovariance = identity(dimension);\n\tfor (let i = 0; i < nSensors; i++) {\n\t\tconcatenatedObservedProjection = concatenatedObservedProjection.concat(copy(oneSensorObservedProjection));\n\n\t\tfor (const [rIndex, r] of sensorCovarianceFormatted.entries()) {\n\t\t\tfor (const [cIndex, c] of r.entries()) {\n\t\t\t\tconcatenatedCovariance[rIndex + (i * sensorDimension)][cIndex + (i * sensorDimension)] = c;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn Object.assign({}, options, {\n\t\tdimension,\n\t\tobservedProjection: concatenatedObservedProjection,\n\t\tcovariance: concatenatedCovariance,\n\t});\n};\n","const {padWithZeroCols: padWithZeros} = require('simple-linalg');\nconst {identity} = require('simple-linalg');\n/**\n*Builds the stateProjection given an observedProjection\n*@param {ObservationConfig} observation\n*@param {DynamicConfig} dynamic\n*@returns {ObservationConfig, DynamicConfig} the model containing the created stateProjection\n*/\n\nmodule.exports = function ({observation, dynamic}) {\n\tconst {observedProjection, stateProjection} = observation;\n\tconst observationDimension = observation.dimension;\n\tconst dynamicDimension = dynamic.dimension;\n\tif (observedProjection && stateProjection) {\n\t\tthrow (new TypeError('You cannot use both observedProjection and stateProjection'));\n\t}\n\n\tif (observedProjection) {\n\t\tconst stateProjection = padWithZeros(observedProjection, {columns: dynamicDimension});\n\t\treturn {\n\t\t\tobservation: Object.assign({}, observation, {\n\t\t\t\tstateProjection,\n\t\t\t}),\n\t\t\tdynamic,\n\t\t};\n\t}\n\n\tif (observationDimension && dynamicDimension && !stateProjection) {\n\t\tconst observationMatrix = identity(observationDimension);\n\t\treturn {\n\t\t\tobservation: Object.assign({}, observation, {\n\t\t\t\tstateProjection: padWithZeros(observationMatrix, {columns: dynamicDimension}),\n\t\t\t}),\n\t\t\tdynamic,\n\t\t};\n\t}\n\n\treturn {observation, dynamic};\n};\n","/**\n*Verifies that dynamic.dimension and observation.dimension are set\n*@param {ObservationConfig} observation\n*@param {DynamicConfig} dynamic\n*/\n\nmodule.exports = function ({observation, dynamic}) {\n\tconst dynamicDimension = dynamic.dimension;\n\tconst observationDimension = observation.dimension;\n\tif (!dynamicDimension || !observationDimension) {\n\t\tthrow (new TypeError('Dimension is not set'));\n\t}\n\n\treturn {observation, dynamic};\n};\n","const {diag} = require('simple-linalg');\nconst polymorphMatrix = require('../utils/polymorph-matrix.js');\n\n/**\n*Initializes the dynamic.init when not given\n*@param {ObservationConfig} observation\n*@param {DynamicConfig} dynamic\n*@returns {CoreConfig}\n*/\n\nmodule.exports = function ({observation, dynamic}) {\n\tif (!dynamic.init) {\n\t\tconst huge = 1e6;\n\t\tconst dynamicDimension = dynamic.dimension;\n\t\tconst meanArray = new Array(dynamicDimension).fill(0);\n\t\tconst covarianceArray = new Array(dynamicDimension).fill(huge);\n\t\tconst withInitOptions = {\n\t\t\tobservation,\n\t\t\tdynamic: Object.assign({}, dynamic, {\n\t\t\t\tinit: {\n\t\t\t\t\tmean: meanArray.map(element => [element]),\n\t\t\t\t\tcovariance: diag(covarianceArray),\n\t\t\t\t\tindex: -1,\n\t\t\t\t},\n\t\t\t}),\n\t\t};\n\t\treturn withInitOptions;\n\t}\n\n\tif (dynamic.init && !dynamic.init.mean) {\n\t\tthrow (new Error('dynamic.init should have a mean key'));\n\t}\n\n\tdynamic.init = Object.assign({}, dynamic.init, {\n\t\tcovariance: polymorphMatrix(dynamic.init.covariance, {dimension: dynamic.dimension}),\n\t});\n\n\treturn {observation, dynamic};\n};\n","/**\n*Verifies that dimensions are matching and set dynamic.dimension and observation.dimension\n* with respect of stateProjection and transition dimensions\n*@param {ObservationConfig} observation\n*@param {DynamicConfig} dynamic\n*@returns {ObservationConfig, DynamicConfig}\n*/\n\nmodule.exports = function ({observation, dynamic}) {\n\tconst {stateProjection} = observation;\n\tconst {transition} = dynamic;\n\tconst dynamicDimension = dynamic.dimension;\n\tconst observationDimension = observation.dimension;\n\n\tif (dynamicDimension && observationDimension && Array.isArray(stateProjection) && (dynamicDimension !== stateProjection[0].length || observationDimension !== stateProjection.length)) {\n\t\tthrow (new TypeError('stateProjection dimensions not matching with observation and dynamic dimensions'));\n\t}\n\n\tif (dynamicDimension && Array.isArray(transition) && dynamicDimension !== transition.length) {\n\t\tthrow (new TypeError('transition dimension not matching with dynamic dimension'));\n\t}\n\n\tif (Array.isArray(stateProjection)) {\n\t\treturn {\n\t\t\tobservation: Object.assign({}, observation, {\n\t\t\t\tdimension: stateProjection.length,\n\t\t\t}),\n\t\t\tdynamic: Object.assign({}, dynamic, {\n\t\t\t\tdimension: stateProjection[0].length,\n\t\t\t}),\n\t\t};\n\t}\n\n\tif (Array.isArray(transition)) {\n\t\treturn {\n\t\t\tobservation,\n\t\t\tdynamic: Object.assign({}, dynamic, {\n\t\t\t\tdimension: transition.length,\n\t\t\t}),\n\t\t};\n\t}\n\n\treturn {observation, dynamic};\n};\n","const {subtract: sub, transpose, matMul, invert, elemWise, subSquareMatrix} = require('simple-linalg');\nconst arrayToMatrix = require('./utils/array-to-matrix.js');\nconst checkMatrix = require('./utils/check-matrix.js');\nconst checkCovariance = require('./utils/check-covariance');\n\n/**\n * Class representing a multi dimensionnal gaussian, with his mean and his covariance\n * @property {Number} [index=0] the index of the State in the process, this is not mandatory for simple Kalman Filter, but is needed for most of the use case of extended kalman filter\n * @property {Array.<Array.<Number>>} covariance square matrix of size dimension\n * @property {Array.<Array<Number>>} mean column matrix of size dimension x 1\n */\nclass State {\n\tconstructor({mean, covariance, index}) {\n\t\tthis.mean = mean;\n\t\tthis.covariance = covariance;\n\t\tthis.index = index;\n\t}\n\n\t/**\n\t* Check the consistency of the State\n\t* @param {Object} options\n\t* @returns {Null}\n\t* @see check\n\t*/\n\tcheck(options) {\n\t\tthis.constructor.check(this, options);\n\t}\n\n\t/**\n\t* Check the consistency of the State's attributes\n\t* @param {State} state\n\t* @param {Object} [options={}]\n\t* @param {Array} [options.dimension=null] if defined check the dimension of the state\n\t* @param {String} [options.title=null] used to log error mor explicitly\n\t* @param {Boolean} options.eigen\n\t* @returns {Null}\n\t*/\n\n\tstatic check(state, {dimension = null, title = null, eigen} = {}) {\n\t\tif (!(state instanceof State)) {\n\t\t\tthrow (new TypeError(\n\t\t\t\t'The argument is not a state \\n'\n        + 'Tips: maybe you are using 2 different version of kalman-filter in your npm deps tree',\n\t\t\t));\n\t\t}\n\n\t\tconst {mean, covariance} = state; // Index\n\t\tconst meanDimension = mean.length;\n\t\tif (typeof (dimension) === 'number' && meanDimension !== dimension) {\n\t\t\tthrow (new Error(`[${title}] State.mean ${mean} with dimension ${meanDimension} does not match expected dimension (${dimension})`));\n\t\t}\n\n\t\tcheckMatrix(mean, [meanDimension, 1], title ? title + '.mean' : 'mean');\n\t\tcheckMatrix(covariance, [meanDimension, meanDimension], title ? title + '.covariance' : 'covariance');\n\t\tcheckCovariance({covariance, eigen}, title ? title + '.covariance' : 'covariance');\n\t\t// If (typeof (index) !== 'number') {\n\t\t// \tthrow (new TypeError('t must be a number'));\n\t\t// }\n\t}\n\n\t/**\n\t* Multiply state with matrix\n\t* @param {State} state\n\t* @param {Array.<Array.<Number>>} matrix\n\t* @returns {State}\n\t*/\n\tstatic matMul({state, matrix}) {\n\t\tconst covariance = matMul(\n\t\t\tmatMul(matrix, state.covariance),\n\t\t\ttranspose(matrix),\n\t\t);\n\t\tconst mean = matMul(matrix, state.mean);\n\n\t\treturn new State({\n\t\t\tmean,\n\t\t\tcovariance,\n\t\t\tindex: state.index,\n\t\t});\n\t}\n\n\t/**\n\t* From a state in n-dimension create a state in a subspace\n\t* If you see the state as a N-dimension gaussian,\n\t* this can be viewed as the sub M-dimension gaussian (M < N)\n\t* @param {Array.<Number>} obsIndexes list of dimension to extract,  (M < N <=> obsIndexes.length < this.mean.length)\n\t* @returns {State} subState in subspace, with subState.mean.length === obsIndexes.length\n\t*/\n\tsubState(obsIndexes) {\n\t\tconst state = new State({\n\t\t\tmean: obsIndexes.map(i => this.mean[i]),\n\t\t\tcovariance: subSquareMatrix(this.covariance, obsIndexes),\n\t\t\tindex: this.index,\n\t\t});\n\t\treturn state;\n\t}\n\n\t/**\n\t* @typedef {Object} DetailedMahalanobis\n\t* @property {Array.<[Number]>} diff\n\t* @property {Array.<Array.<Number>>} covarianceInvert\n\t* @property {Number} value\n\t*/\n\t/**\n\t* Simple Malahanobis distance between the distribution (this) and a point\n\t* @param {Array.<[Number]>} point a Nx1 matrix representing a point\n\t* @returns {DetailedMahalanobis}\n\t*/\n\trawDetailedMahalanobis(point) {\n\t\tconst diff = sub(this.mean, point);\n\t\tthis.check();\n\t\tconst covarianceInvert = invert(this.covariance);\n\t\tif (covarianceInvert === null) {\n\t\t\tthis.check({eigen: true});\n\t\t\tthrow (new Error(`Cannot invert covariance ${JSON.stringify(this.covariance)}`));\n\t\t}\n\n\t\tconst diffTransposed = transpose(diff);\n\n\t\t// Console.log('covariance in obs space', covarianceInObservationSpace);\n\n\t\tconst value = Math.sqrt(\n\t\t\tmatMul(\n\t\t\t\tmatMul(\n\t\t\t\t\tdiffTransposed,\n\t\t\t\t\tcovarianceInvert,\n\t\t\t\t),\n\t\t\t\tdiff,\n\t\t\t),\n\t\t);\n\t\tif (Number.isNaN(value)) {\n\t\t\tconsole.log({diff, covarianceInvert, this: this, point}, matMul(\n\t\t\t\tmatMul(\n\t\t\t\t\tdiffTransposed,\n\t\t\t\t\tcovarianceInvert,\n\t\t\t\t),\n\t\t\t\tdiff,\n\t\t\t));\n\t\t\tthrow (new Error('mahalanobis is NaN'));\n\t\t}\n\n\t\treturn {\n\t\t\tdiff,\n\t\t\tcovarianceInvert,\n\t\t\tvalue,\n\t\t};\n\t}\n\n\t/**\n\t* Malahanobis distance is made against an observation, so the mean and covariance\n\t* are projected into the observation space\n\t* @param {KalmanFilter} kf kalman filter use to project the state in observation's space\n\t* @param {Observation} observation\n\t* @param {Array.<Number>} obsIndexes list of indexes of observation state to use for the mahalanobis distance\n\t* @returns {DetailedMahalanobis}\n\t*/\n\tdetailedMahalanobis({kf, observation, obsIndexes}) {\n\t\tif (observation.length !== kf.observation.dimension) {\n\t\t\tthrow (new Error(`Mahalanobis observation ${observation} (dimension: ${observation.length}) does not match with kf observation dimension (${kf.observation.dimension})`));\n\t\t}\n\n\t\tlet correctlySizedObservation = arrayToMatrix({observation, dimension: observation.length});\n\n\t\tconst stateProjection = kf.getValue(kf.observation.stateProjection, {});\n\n\t\tlet projectedState = this.constructor.matMul({state: this, matrix: stateProjection});\n\n\t\tif (Array.isArray(obsIndexes)) {\n\t\t\tprojectedState = projectedState.subState(obsIndexes);\n\t\t\tcorrectlySizedObservation = obsIndexes.map(i => correctlySizedObservation[i]);\n\t\t}\n\n\t\treturn projectedState.rawDetailedMahalanobis(correctlySizedObservation);\n\t}\n\n\t/**\n\t* @param {Object} options @see detailedMahalanobis\n\t* @returns {Number}\n\t*/\n\tmahalanobis(options) {\n\t\tconst result = this.detailedMahalanobis(options).value;\n\t\tif (Number.isNaN(result)) {\n\t\t\tthrow (new TypeError('mahalanobis is NaN'));\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/**\n\t* Bhattacharyya distance is made against in the observation space\n\t* to do it in the normal space see state.bhattacharyya\n\t* @param {KalmanFilter} kf kalman filter use to project the state in observation's space\n\t* @param {State} state\n\t* @param {Array.<Number>} obsIndexes list of indexes of observation state to use for the bhattacharyya distance\n\t* @returns {Number}\n\t*/\n\tobsBhattacharyya({kf, state, obsIndexes}) {\n\t\tconst stateProjection = kf.getValue(kf.observation.stateProjection, {});\n\n\t\tlet projectedSelfState = this.constructor.matMul({state: this, matrix: stateProjection});\n\t\tlet projectedOtherState = this.constructor.matMul({state, matrix: stateProjection});\n\n\t\tif (Array.isArray(obsIndexes)) {\n\t\t\tprojectedSelfState = projectedSelfState.subState(obsIndexes);\n\t\t\tprojectedOtherState = projectedOtherState.subState(obsIndexes);\n\t\t}\n\n\t\treturn projectedSelfState.bhattacharyya(projectedOtherState);\n\t}\n\n\t/**\n\t* @param {State} otherState other state to compare with\n\t* @returns {Number}\n\t*/\n\tbhattacharyya(otherState) {\n\t\tconst {covariance, mean} = this;\n\t\tconst average = elemWise([covariance, otherState.covariance], ([a, b]) => (a + b) / 2);\n\n\t\tlet covarInverted;\n\t\ttry {\n\t\t\tcovarInverted = invert(average);\n\t\t} catch (error) {\n\t\t\tconsole.log('Cannot invert', average);\n\t\t\tthrow (error);\n\t\t}\n\n\t\tconst diff = sub(mean, otherState.mean);\n\n\t\treturn matMul(transpose(diff), matMul(covarInverted, diff))[0][0];\n\t}\n}\n\nmodule.exports = State;\n","/**\n*Returns the corresponding matrix in dim*1, given an dim matrix, and checks\n* if corresponding with the observation dimension\n*@param {Array.<Number> | Array.<Array.<Number>>} observation\n*@param {Number} dimension\n*@returns {Array.<Array.<Number>>}\n*/\n\nmodule.exports = function ({observation, dimension}) {\n\tif (!Array.isArray(observation)) {\n\t\tif (dimension === 1 && typeof (observation) === 'number') {\n\t\t\treturn [[observation]];\n\t\t}\n\n\t\tthrow (new TypeError(`The observation (${observation}) should be an array (dimension: ${dimension})`));\n\t}\n\n\tif (observation.length !== dimension) {\n\t\tthrow (new TypeError(`Observation (${observation.length}) and dimension (${dimension}) not matching`));\n\t}\n\n\tif (typeof (observation[0]) === 'number' || observation[0] === null) {\n\t\treturn observation.map(element => [element]);\n\t}\n\n\treturn observation;\n};\n","const tolerance = 0.1;\nconst Matrix = require('@rayyamhk/matrix');\nconst checkMatrix = require('./check-matrix');\n\nconst checkDefinitePositive = function (covariance, tolerance = 1e-10) {\n\tconst covarianceMatrix = new Matrix(covariance);\n\tconst eigenvalues = covarianceMatrix.eigenvalues();\n\tfor (const eigenvalue of eigenvalues) {\n\t\tif (eigenvalue <= -tolerance) {\n\t\t\tconsole.log(covariance, eigenvalue);\n\t\t\tthrow new Error(`Eigenvalue should be positive (actual: ${eigenvalue})`);\n\t\t}\n\t}\n\n\tconsole.log('is definite positive', covariance);\n};\n\nconst checkSymetric = function (covariance, title = 'checkSymetric') {\n\tfor (const [rowId, row] of covariance.entries()) {\n\t\tfor (const [colId, item] of row.entries()) {\n\t\t\tif (rowId === colId && item < 0) {\n\t\t\t\tthrow new Error(`[${title}] Variance[${colId}] should be positive (actual: ${item})`);\n\t\t\t} else if (Math.abs(item) > Math.sqrt(covariance[rowId][rowId] * covariance[colId][colId])) {\n\t\t\t\tconsole.log(covariance);\n\t\t\t\tthrow new Error(`[${title}] Covariance[${rowId}][${colId}] should verify Cauchy Schwarz Inequality `\n\t\t\t\t+ `(expected: |x| <= sqrt(${covariance[rowId][rowId]} * ${covariance[colId][colId]})`\n\t\t\t\t+ ` actual: ${item})`);\n\t\t\t} else if (Math.abs(item - covariance[colId][rowId]) > tolerance) {\n\t\t\t\tthrow new Error(`[${title}] Covariance[${rowId}][${colId}] should equal Covariance[${colId}][${rowId}] `\n\t\t\t+ ` (actual diff: ${Math.abs(item - covariance[colId][rowId])})  = ${item} - ${covariance[colId][rowId]}\\n`\n\t\t\t+ `${covariance.join('\\n')} is invalid`,\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n};\n\nmodule.exports = function ({covariance, eigen = false}) {\n\tcheckMatrix(covariance);\n\tcheckSymetric(covariance);\n\tif (eigen) {\n\t\tcheckDefinitePositive(covariance);\n\t}\n};\n","const checkShape = require('./check-shape');\n\nmodule.exports = function (matrix, shape, title = 'checkMatrix') {\n\tif (!Array.isArray(matrix)) {\n\t\tthrow (new TypeError(`[${title}] should be a 2-level array matrix and is ${matrix}`));\n\t}\n\n\tfor (const row of matrix) {\n\t\tif (!Array.isArray(row)) {\n\t\t\tthrow (new TypeError(`[${title}] 1-level array should be a matrix ${JSON.stringify(matrix)}`));\n\t\t}\n\t}\n\n\tif (matrix.reduce((a, b) => a.concat(b)).some(a => Number.isNaN(a))) {\n\t\tthrow (new Error(\n\t\t\t`[${title}] Matrix should not have a NaN\\nIn : \\n`\n\t\t\t+ matrix.join('\\n'),\n\t\t));\n\t}\n\n\tif (shape) {\n\t\tcheckShape(matrix, shape, title);\n\t}\n};\n","const checkShape = function (matrix, shape, title = 'checkShape') {\n\tif (matrix.length !== shape[0]) {\n\t\tthrow (new Error(`[${title}] expected size (${shape[0]}) and length (${matrix.length}) does not match`));\n\t}\n\n\tif (shape.length > 1) {\n\t\treturn matrix.forEach(m => checkShape(m, shape.slice(1), title));\n\t}\n};\n\nmodule.exports = checkShape;\n","const checkCovariance = require('./check-covariance');\n\nmodule.exports = function ({correlation, variance}) {\n\tcheckCovariance({covariance: correlation});\n\treturn correlation.map((c, rowIndex) => c.map((a, colIndex) => a * Math.sqrt(variance[colIndex] * variance[rowIndex])));\n};\n","const checkCovariance = require('./check-covariance');\n\nmodule.exports = function (covariance) {\n\tcheckCovariance({covariance});\n\tconst variance = covariance.map((_, i) => covariance[i][i]);\n\n\treturn {\n\t\tvariance,\n\t\tcorrelation: covariance.map((c, rowIndex) => c.map((a, colIndex) => a / Math.sqrt(variance[colIndex] * variance[rowIndex]))),\n\t};\n};\n","const uniq = require('./uniq.js');\n\nconst limit = 100;\n\n/**\n*Equivalent to the Object.assign method, takes several arguments and creates a new object corresponding to the assignment of the arguments\n* @param {Object} args\n* @param {Number} step\n* @returns {Object}\n*/\nconst deepAssign = function (args, step) {\n\tif (step > limit) {\n\t\tthrow (new Error(`In deepAssign, number of recursive call (${step}) reached limit (${limit}), deepAssign is not working on  self-referencing objects`));\n\t}\n\n\tconst filterArguments = args.filter(arg => (arg) !== undefined && arg !== null);\n\tconst lastArgument = filterArguments[filterArguments.length - 1];\n\tif (filterArguments.length === 1) {\n\t\treturn filterArguments[0];\n\t}\n\n\tif (typeof (lastArgument) !== 'object' || Array.isArray(lastArgument)) {\n\t\treturn lastArgument;\n\t}\n\n\tif (filterArguments.length === 0) {\n\t\treturn null;\n\t}\n\n\tconst objectsArguments = filterArguments.filter(arg => typeof (arg) === 'object');\n\tlet keys = [];\n\tfor (const arg of objectsArguments) {\n\t\tkeys = keys.concat(Object.keys(arg));\n\t}\n\n\tconst uniqKeys = uniq(keys);\n\tconst result = {};\n\tfor (const key of uniqKeys) {\n\t\tconst values = objectsArguments.map(arg => arg[key]);\n\t\tresult[key] = deepAssign(values, step + 1);\n\t}\n\n\treturn result;\n};\n\nmodule.exports = ((...args) => deepAssign(args, 0));\n","/**\n* @param {Object} opts\n* @param {Array.<Array.<Number>>} opts.measures a list of measure, size is LxN L the number of sample, N the dimension\n* @param {Array.<Array.<Number>>} opts.averages a list of averages, size is LxN L the number of sample, N the dimension\n* @returns {Array.<Array.<Number>>} covariance matrix size is NxN\n*/\n\nmodule.exports = function ({measures, averages}) {\n\tconst l = measures.length;\n\tconst n = measures[0].length;\n\n\tif (l === 0) {\n\t\tthrow (new Error('Cannot find covariance for empty sample'));\n\t}\n\n\treturn (new Array(n).fill(1)).map((_, rowIndex) => (new Array(n).fill(1)).map((_, colIndex) => {\n\t\tconst stds = measures.map((m, i) => (m[rowIndex] - averages[i][rowIndex]) * (m[colIndex] - averages[i][colIndex]));\n\t\tconst result = stds.reduce((a, b) => a + b) / l;\n\t\tif (Number.isNaN(result)) {\n\t\t\tthrow (new TypeError('result is NaN'));\n\t\t}\n\n\t\treturn result;\n\t}));\n};\n","/**\n* @typedef {Number | Array.<Number> | Array.<Array.<Number>>} CovarianceParam\n*/\nconst {diag} = require('simple-linalg');\nconst checkMatrix = require('./check-matrix');\n/**\n* If cov is a number, result will be Identity*cov\n* If cov is an Array.<Number>, result will be diag(cov)\n* If cov is an Array.<Array.<Number>>, result will be cov\n* @param {CovarianceParam} cov\n* @param {Number} dimension\n* @returns {Array.<Array.<Number>>}\n*/\nmodule.exports = function (cov, {dimension, title = 'polymorph'} = {}) {\n\tif (typeof (cov) === 'number' || Array.isArray(cov)) {\n\t\tif (typeof (cov) === 'number' && typeof (dimension) === 'number') {\n\t\t\treturn diag(new Array(dimension).fill(cov));\n\t\t}\n\n\t\tif ((Array.isArray(cov)) && (Array.isArray(cov[0]))) {\n\t\t\tlet shape;\n\t\t\tif (typeof (dimension) === 'number') {\n\t\t\t\tshape = [dimension, dimension];\n\t\t\t}\n\n\t\t\tcheckMatrix(cov, shape, title);\n\t\t\treturn cov;\n\t\t}\n\n\t\tif ((Array.isArray(cov)) && (typeof (cov[0]) === 'number')) {\n\t\t\treturn diag(cov);\n\t\t}\n\t}\n\n\treturn cov;\n};\n","// From observationTracks to movingAverageGroundTruthsStates with speed\n\nconst {matMul, invert} = require('simple-linalg');\n\nmodule.exports = function ({observation, obsIndexes, selectedStateProjection, invertSelectedStateProjection}) {\n\tif (!observation) {\n\t\treturn null;\n\t}\n\n\tconst value = observation.observation || observation;\n\n\tconst vec = obsIndexes.map(i => {\n\t\tif ((value[i]) === undefined) {\n\t\t\tthrow (new TypeError(`obsIndexes (${obsIndexes}) is not matching with observation (${observation})`));\n\t\t}\n\n\t\treturn [value[i]];\n\t});\n\n\tconst inverse = invertSelectedStateProjection || invert(selectedStateProjection);\n\n\tif (inverse === null) {\n\t\tthrow (new Error('selectedStateProjection is not invertible, please provide invertSelectedStateProjection'));\n\t}\n\n\tconst out = matMul(inverse, vec);\n\n\treturn out\n\t\t.map(v => v[0])\n\t\t.map(v => {\n\t\t\tif (Number.isNaN(v)) {\n\t\t\t\tthrow (new TypeError('NaN in projection'));\n\t\t\t}\n\n\t\t\treturn v;\n\t\t});\n};\n","// Const {diag} = require('simple-linalg');;\n\n/**\n* @callback MatrixCallback\n* @returns <Array.<Array.<Number>>\n*/\n\n/**\n* Tranforms:\n** a 2d array into a function (() => array)\n** a 1d array into a function (() => diag(array))\n*@param {Array.<Number> | Array.<Array.<Number>>} array\n*@returns {MatrixCallback}\n*/\n\nmodule.exports = function (array, {label = null} = {}) {\n\tif (typeof (array) === 'function') {\n\t\treturn array;\n\t}\n\n\tif (Array.isArray(array)) {\n\t\treturn array;\n\t}\n\n\tthrow (new Error(`${label === null ? '' : label + ' : '}Only arrays and functions are authorized (got: \"${array}\")`));\n};\n","module.exports = function (array) {\n\treturn array.filter((value, index) =>\n\t\tarray.indexOf(value) === index,\n\t);\n};\n","\"use strict\";\n\n/**\r\n * Calculates the argument of a Complex Number which is restricted to the interval [ 0, 2π ).<br><br>\r\n * \r\n * The argument of the Complex Number is the angle between positive real-axis\r\n * and the vector representing the Complex Number on Complex plane.<br><br>\r\n * \r\n * If the given Complex Number is considered as 0, returns undefined.\r\n * @memberof Complex\r\n * @instance\r\n * @returns {number} The argument of the Complex Number\r\n */\nfunction getArgument() {\n  var x = this.re;\n  var y = this.im;\n  var epsilon = 1 / (Math.pow(10, 15) * 2);\n\n  if (Math.abs(x) < epsilon && Math.abs(y) < epsilon) {\n    return undefined;\n  }\n\n  if (x === 0) {\n    if (y > 0) {\n      return Math.PI * 0.5;\n    }\n\n    return Math.PI * 1.5;\n  }\n\n  if (y === 0) {\n    if (x > 0) {\n      return 0;\n    }\n\n    return Math.PI;\n  }\n\n  if (x > 0 && y > 0) {\n    return Math.atan(y / x);\n  }\n\n  if (x < 0 && y > 0) {\n    return Math.PI - Math.atan(y / (x * -1));\n  }\n\n  if (x < 0 && y < 0) {\n    return Math.PI + Math.atan(y * -1 / (x * -1));\n  }\n\n  return Math.PI * 2 - Math.atan(y * -1 / x);\n}\n\nmodule.exports = getArgument;","\"use strict\";\n\n/**\r\n * Gets the imaginary part of a Complex Number.\r\n * @memberof Complex\r\n * @instance\r\n * @returns {number} The imaginary part of the Complex Number\r\n */\nfunction getImaginary() {\n  return this.im;\n}\n\nmodule.exports = getImaginary;","\"use strict\";\n\n/**\r\n * Calculates the modulus of a Complex Number.<br><br>\r\n * \r\n * The modulus of the complex number is the length of the vector\r\n * representing the complex number on complex plane.\r\n * @memberof Complex\r\n * @instance\r\n * @returns {number} The modulus of the Complex Number\r\n */\nfunction getModulus() {\n  return Math.sqrt(Math.pow(this.re, 2) + Math.pow(this.im, 2));\n}\n\nmodule.exports = getModulus;","\"use strict\";\n\n/**\r\n * Gets the real part of a Complex Number.\r\n * @memberof Complex\r\n * @instance\r\n * @returns {number} The real part of the Complex Number\r\n */\nfunction getReal() {\n  return this.re;\n}\n\nmodule.exports = getReal;","\"use strict\";\n\n/**\r\n * Gets the stringified and formatted Complex Number.\r\n * @memberof Complex\r\n * @instance\r\n * @returns {string} The stringified and formatted Complex Number\r\n */\nfunction toString() {\n  var re = this.re,\n      im = this.im;\n\n  if (Number.isNaN(re) || Number.isNaN(im)) {\n    return 'NaN';\n  }\n\n  if (re === 0 && im === 0) {\n    return '0';\n  }\n\n  if (re === 0) {\n    if (im === 1) {\n      return 'i';\n    }\n\n    if (im === -1) {\n      return '-i';\n    }\n\n    return \"\".concat(im, \"i\");\n  }\n\n  if (im === 0) {\n    return \"\".concat(re);\n  }\n\n  if (im > 0) {\n    if (im === 1) {\n      return \"\".concat(re, \" + i\");\n    }\n\n    return \"\".concat(re, \" + \").concat(im, \"i\");\n  }\n\n  if (im === -1) {\n    return \"\".concat(re, \" - i\");\n  }\n\n  return \"\".concat(re, \" - \").concat(Math.abs(im), \"i\");\n}\n\nmodule.exports = toString;","\"use strict\";\n\n/**\r\n * Calculates the inverse cosine of a Complex Number.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Any Complex Number\r\n * @returns {Complex} The result of inverse cosine function\r\n */\nfunction acos(num) {\n  return this.subtract(new this(Math.PI / 2), this.asin(num));\n}\n\nmodule.exports = acos;","\"use strict\";\n\n/**\r\n * Calculates the inverse cotangent of a Complex Number.\r\n * The domain of this function is C / { i , -i , 0 }.<br><br>\r\n * \r\n * If the argument is out of its domain, it returns Complex.NaN.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Any Complex Number except i, -i and 0\r\n * @returns {Complex} The result of inverse cotangent function\r\n */\nfunction acot(num) {\n  return this.atan(this.inverse(num));\n}\n\nmodule.exports = acot;","\"use strict\";\n\n/**\r\n * Calculates the inverse cosecant of a Complex Number.\r\n * The domain of this function is C / { 0 }.<br><br>\r\n * \r\n * If the argument is out of its domain, it returns Complex.NaN.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Any Complex Number except 0\r\n * @returns {Complex} The result of inverse cosecant function\r\n */\nfunction acsc(num) {\n  return this.asin(this.inverse(num));\n}\n\nmodule.exports = acsc;","\"use strict\";\n\n/**\r\n * Calculates the sum of two Complex Number.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num1 - The Complex Number on the left of '+' operator.\r\n * @param {Complex} num2 - The Complex Number on the right of '+' operator.\r\n * @returns {Complex} The sum of two Complex Numbers\r\n */\nfunction add(num1, num2) {\n  if (!(num1 instanceof this) || !(num2 instanceof this)) {\n    return this.NaN;\n  }\n\n  return new this(num1.re + num2.re, num1.im + num2.im);\n}\n\nmodule.exports = add;","\"use strict\";\n\n/**\r\n * Calculates the inverse secant of a Complex Number.\r\n * The domain of this function is C / { 0 }.<br><br>\r\n * \r\n * If the argument is out of its domain, it returns Complex.NaN.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Any Complex Number except 0\r\n * @returns {Complex} The result of inverse secant function\r\n */\nfunction asec(num) {\n  return this.acos(this.inverse(num));\n}\n\nmodule.exports = asec;","\"use strict\";\n\n/**\r\n * Calculates the inverse sine of a Complex Number.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Any Complex Number\r\n * @returns {Complex} The result of inverse sine function\r\n */\nfunction asin(num) {\n  return this.multiply(new this(0, -1), this.log(this.add(this.multiply(new this(0, 1), num), this.pow(this.subtract(this.ONE, this.pow(num, 2)), 0.5))));\n}\n\nmodule.exports = asin;","\"use strict\";\n\n/**\r\n * Calculates the inverse tangent of a Complex Number.\r\n * The domain of this function is C / { i , -i }.<br><br>\r\n * \r\n * If the argument is out of its domain, it returns Complex.NaN.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Any Complex Number except i and -i\r\n * @returns {Complex} The result of inverse tangent function\r\n */\nfunction atan(num) {\n  return this.multiply(new this(0, 1 / 2), this.subtract(this.log(this.subtract(this.ONE, this.multiply(new this(0, 1), num))), this.log(this.add(this.ONE, this.multiply(new this(0, 1), num)))));\n}\n\nmodule.exports = atan;","\"use strict\";\n\n/**\r\n * Calculates the complex conjugate of the Complex Number.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Complex number\r\n * @returns {Complex} The complex conjugate of the Complex Number\r\n */\nfunction conjugate(num) {\n  if (!(num instanceof this)) {\n    return this.NaN;\n  }\n\n  return new this(num.getReal(), num.getImaginary() * -1);\n}\n\nmodule.exports = conjugate;","\"use strict\";\n\n/**\r\n * Calculates the cosine of a Complex Number.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Any Complex Number\r\n * @returns {Complex} The result of cosine function\r\n */\nfunction cos(num) {\n  if (!(num instanceof this)) {\n    return this.NaN;\n  }\n\n  var a = num.getReal();\n  var b = num.getImaginary();\n  return new this(Math.cos(a) * Math.cosh(b), Math.sin(a) * Math.sinh(b) * -1);\n}\n\nmodule.exports = cos;","\"use strict\";\n\n/**\r\n * Calculates the cotangent of a Complex Number.\r\n * The domain of this function is C / { kπ/2 : k is any integer }.<br><br>\r\n * \r\n * If the argument is out of its domain, it returns Complex.NaN.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Any Complex Number which is not the multiple of π/2\r\n * @returns {Complex} The result of cotangent function\r\n */\nfunction cot(num) {\n  return this.divide(this.ONE, this.tan(num));\n}\n\nmodule.exports = cot;","\"use strict\";\n\n/**\r\n * Calculates the cosecant of a Complex Number.\r\n * The domain of this function is C / { kπ : k is any integer }.<br><br>\r\n * \r\n * If the argument is out of its domain, it returns Complex.NaN.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Any Complex Number which is not the multiple of π\r\n * @returns {Complex} The result of cosecant function\r\n */\nfunction csc(num) {\n  return this.divide(this.ONE, this.sin(num));\n}\n\nmodule.exports = csc;","\"use strict\";\n\n/**\r\n * Calculates the quotient of two Complex Number.<br><br>\r\n * \r\n * Note that if the denominator is considered as 0,\r\n * returns Complex.NaN instead of Infinity.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num1 - The Complex Number on the left of '/' operator.\r\n * @param {Complex} num2 - The Complex Number on the right of '/' operator.\r\n * @returns {Complex} The quotient of two Complex Numbers\r\n */\nfunction divide(num1, num2) {\n  if (!(num1 instanceof this) || !(num2 instanceof this)) {\n    return this.NaN;\n  }\n\n  var a = num1.re;\n  var b = num1.im;\n  var c = num2.re;\n  var d = num2.im;\n\n  if (Math.abs(c) < this.EPSILON && Math.abs(d) < this.EPSILON) {\n    return this.NaN;\n  }\n\n  var denominator = Math.pow(c, 2) + Math.pow(d, 2);\n  return new this((a * c + b * d) / denominator, (b * c - a * d) / denominator);\n}\n\nmodule.exports = divide;","\"use strict\";\n\n/**\r\n * Calculates the exponential function with base E.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Exponent\r\n * @returns {Complex} The value of E to the power of num\r\n */\nfunction exp(num) {\n  if (!(num instanceof this)) {\n    return this.NaN;\n  }\n\n  var re = num.getReal();\n  var theta = num.getImaginary();\n  var r = Math.exp(re);\n  return new this(r * Math.cos(theta), r * Math.sin(theta));\n}\n\nmodule.exports = exp;","\"use strict\";\n\n/**\r\n * Calculates the inverse of the Complex Number.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Complex Number\r\n * @returns {number} Inverse of the Complex Number\r\n */\nfunction inverse(num) {\n  if (!(num instanceof this)) {\n    return this.NaN;\n  }\n\n  return this.divide(this.ONE, num);\n}\n\nmodule.exports = inverse;","\"use strict\";\n\n/**\r\n * Determines whether two Complex Numbers are considered as identical.<br><br>\r\n * \r\n * Two Complex Numbers are considered as identical if either\r\n * both are NaN or both real and imaginary parts are extremely closed.<br><br>\r\n * \r\n * The test criterion is Math.abs(x - y) < 1 / (10 ** digit * 2).\r\n * For default value 15, it should be 5e-16.\r\n * That means if the difference of two numbers is less than 5e-16,\r\n * they are considered as same value.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num1 - Complex Number\r\n * @param {Complex} num2 - Complex Number\r\n * @param {number} [digit=15] - Number of significant digits\r\n * @returns {boolean} Returns true if two Complex Numbers are considered as identical\r\n */\nfunction isEqual(num1, num2) {\n  var digit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 15;\n\n  if (!(num1 instanceof this) || !(num2 instanceof this)) {\n    return false;\n  }\n\n  if (!Number.isInteger(digit) || digit < 0) {\n    throw new Error('Invalid argument: Expected a non-negative integer digit');\n  }\n\n  var EPSILON = 1 / (Math.pow(10, digit) * 2);\n  var a = num1.getReal();\n  var b = num1.getImaginary();\n  var c = num2.getReal();\n  var d = num2.getImaginary();\n\n  if (Number.isNaN(a) && Number.isNaN(b) && Number.isNaN(c) && Number.isNaN(d)) {\n    return true;\n  }\n\n  return Math.abs(a - c) < EPSILON && Math.abs(b - d) < EPSILON;\n}\n\nmodule.exports = isEqual;","\"use strict\";\n\n/**\r\n * Determines whether the Complex Number is NaN or not.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Any Complex number\r\n * @returns {boolean} Returns true if one of real and imaginary part are NaN\r\n */\nfunction isNaN(num) {\n  if (!(num instanceof this)) {\n    return false;\n  }\n\n  var re = num.getReal();\n  var im = num.getImaginary();\n\n  if (Number.isNaN(re) || Number.isNaN(im)) {\n    return true;\n  }\n\n  return false;\n}\n\nmodule.exports = isNaN;","\"use strict\";\n\n/**\r\n * Calculates the natural log of the Complex Number.<br><br>\r\n * \r\n * Note that complex log is a multivalued function,\r\n * and this function only provides the principal value by\r\n * restricting the imaginary part to the interval [0, 2π).\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Complex Number\r\n * @returns {number} Natural log of the Complex Number\r\n */\nfunction log(num) {\n  if (!(num instanceof this)) {\n    return this.NaN;\n  }\n\n  var r = num.getModulus();\n  var theta = num.getArgument();\n\n  if (r < this.EPSILON || theta === undefined) {\n    return this.NaN;\n  }\n\n  return new this(Math.log(r), theta);\n}\n\nmodule.exports = log;","\"use strict\";\n\n/**\r\n * Calculates the product of two Complex Number.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num1 - The Complex Number on the left of '*' operator.\r\n * @param {Complex} num2 - The Complex Number on the right of '*' operator.\r\n * @returns {Complex} The product of two Complex Numbers\r\n */\nfunction multiply(num1, num2) {\n  if (!(num1 instanceof this) || !(num2 instanceof this)) {\n    return this.NaN;\n  }\n\n  var a = num1.re;\n  var b = num1.im;\n  var c = num2.re;\n  var d = num2.im;\n  return new this(a * c - b * d, a * d + b * c);\n}\n\nmodule.exports = multiply;","\"use strict\";\n\n/**\r\n * Calculates the power of the Complex Number.\r\n * The exponent can be any real number or Complex Number<br><br>\r\n * \r\n * You can find the k-th root of complex number by setting the exponent to 1 / k.\r\n * But you should know that it only returns one out of k possible solutions.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Base\r\n * @param {Complex|number} n - Exponent\r\n * @returns {Complex} The result of the exponentiation\r\n */\nfunction pow(num, n) {\n  if (!(num instanceof this) || typeof n !== 'number' && !(n instanceof this)) {\n    return this.NaN;\n  }\n\n  if (typeof n === 'number') {\n    if (!Number.isFinite(n) || Number.isNaN(n)) {\n      return this.NaN;\n    }\n\n    if (n === 0) {\n      return this.ONE;\n    }\n\n    if (this.isEqual(num, this.ZERO)) {\n      return this.ZERO;\n    }\n\n    return this.exp(this.multiply(new this(n, 0), this.log(num)));\n  }\n\n  if (n instanceof this) {\n    return this.exp(this.multiply(n, this.log(num)));\n  }\n\n  return this.NaN;\n}\n\nmodule.exports = pow;","\"use strict\";\n\n/**\r\n * Calculates the secant of a Complex Number.\r\n * The domain of this function is C / { (k + 0.5)π : k is any integer }.<br><br>\r\n * \r\n * If the argument is out of its domain, it returns Complex.NaN.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Any Complex Number which is not in the form of (k + 0.5)π\r\n * @returns {Complex} The result of secant function\r\n */\nfunction sec(num) {\n  return this.divide(this.ONE, this.cos(num));\n}\n\nmodule.exports = sec;","\"use strict\";\n\n/**\r\n * Calculates the sine of a Complex Number.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Any Complex Number\r\n * @returns {Complex} The result of sine function\r\n */\nfunction sin(num) {\n  if (!(num instanceof this)) {\n    return this.NaN;\n  }\n\n  var a = num.getReal();\n  var b = num.getImaginary();\n  return new this(Math.sin(a) * Math.cosh(b), Math.cos(a) * Math.sinh(b));\n}\n\nmodule.exports = sin;","\"use strict\";\n\n/**\r\n * Calculates the difference of two Complex Number.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num1 - The Complex Number on the left of '-' operator.\r\n * @param {Complex} num2 - The Complex Number on the right of '-' operator.\r\n * @returns {Complex} The difference of two Complex Numbers\r\n */\nfunction subtract(num1, num2) {\n  if (!(num1 instanceof this) || !(num2 instanceof this)) {\n    return this.NaN;\n  }\n\n  return new this(num1.re - num2.re, num1.im - num2.im);\n}\n\nmodule.exports = subtract;","\"use strict\";\n\n/**\r\n * Calculates the tangent of a Complex Number.\r\n * The domain of this function is C / { (k + 0.5)π : k is any integer }.<br><br>\r\n * \r\n * If the argument is out of its domain, it returns Complex.NaN.\r\n * @memberof Complex\r\n * @static\r\n * @param {Complex} num - Any Complex Number which is not in the form of (k + 0.5)π\r\n * @returns {Complex} The result of tangent function\r\n */\nfunction tan(num) {\n  return this.divide(this.sin(num), this.cos(num));\n}\n\nmodule.exports = tan;","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/**\r\n * Creates a new Complex Number.\r\n * @namespace Complex\r\n * @class\r\n * @param {number} arg1 - The real part of the Complex Number\r\n * @param {number} arg2 - The imaginary part of the Complex Number\r\n */\nfunction Complex(arg1, arg2) {\n  var type1 = _typeof(arg1);\n\n  var type2 = _typeof(arg2);\n\n  if (type1 === 'number' && type2 === 'undefined') {\n    if (Number.isNaN(arg1) || !Number.isFinite(arg1)) {\n      this.re = NaN;\n      this.im = NaN;\n      return this;\n    }\n\n    this.re = arg1;\n    this.im = 0;\n    return this;\n  }\n\n  if (type1 === 'number' && type2 === 'number') {\n    if (Number.isNaN(arg1) || Number.isNaN(arg2) || !Number.isFinite(arg1) || !Number.isFinite(arg2)) {\n      this.re = NaN;\n      this.im = NaN;\n      return this;\n    }\n\n    this.re = arg1;\n    this.im = arg2;\n    return this;\n  }\n\n  this.re = NaN;\n  this.im = NaN;\n  return this;\n}\n\nmodule.exports = Complex;\nComplex.prototype.getReal = require('./core/instance/getReal');\nComplex.prototype.getImaginary = require('./core/instance/getImaginary');\nComplex.prototype.getModulus = require('./core/instance/getModulus');\nComplex.prototype.getArgument = require('./core/instance/getArgument');\nComplex.prototype.toString = require('./core/instance/toString');\nComplex.isNaN = require('./core/static/isNaN');\nComplex.isEqual = require('./core/static/isEqual');\nComplex.conjugate = require('./core/static/conjugate');\nComplex.inverse = require('./core/static/inverse');\nComplex.add = require('./core/static/add');\nComplex.subtract = require('./core/static/subtract');\nComplex.multiply = require('./core/static/multiply');\nComplex.divide = require('./core/static/divide');\nComplex.exp = require('./core/static/exp');\nComplex.log = require('./core/static/log');\nComplex.pow = require('./core/static/pow');\nComplex.sin = require('./core/static/sin');\nComplex.cos = require('./core/static/cos');\nComplex.tan = require('./core/static/tan');\nComplex.csc = require('./core/static/csc');\nComplex.sec = require('./core/static/sec');\nComplex.cot = require('./core/static/cot');\nComplex.asin = require('./core/static/asin');\nComplex.acos = require('./core/static/acos');\nComplex.atan = require('./core/static/atan');\nComplex.acsc = require('./core/static/acsc');\nComplex.asec = require('./core/static/asec');\nComplex.acot = require('./core/static/acot');\n/**\r\n * It represents NaN in this library. It is equivalent to new Complex(NaN).<br><br>\r\n * \r\n * It is important to know that this library does not introduce the concept of Complex Infinity,\r\n * all Infinity in this library are represented by Complex.NaN.\r\n * @static\r\n */\n\nComplex.NaN = new Complex(NaN);\n/** @static */\n\nComplex.ONE = new Complex(1);\n/** @static */\n\nComplex.ZERO = new Complex(0);\n/** @static */\n\nComplex.PI = new Complex(Math.PI);\n/** @static */\n\nComplex.E = new Complex(Math.E);\n/**\r\n * It represents the value of 5e-16, which is the smallest number considered as non-zero in this library.\r\n * In the other words, any number less than Complex.EPSILON is considered as 0.<br><br>\r\n * \r\n * Note that Complex.EPSILON is number instead of instance of Complex.\r\n * @static\r\n */\n\nComplex.EPSILON = 1 / (Math.pow(10, 15) * 2);","\"use strict\";\n\nmodule.exports = {\n  INVALID_ARRAY: 'Invalid argument: Received a non-array argument',\n  INVALID_MATRIX: 'Invalid argument: Received an invalid matrix',\n  INVALID_SQUARE_MATRIX: 'Invalid argument: Received a non-square matrix',\n  INVALID_UPPER_TRIANGULAR_MATRIX: 'Invalid argument: Received a non upper-triangular matrix',\n  INVALID_LOWER_TRIANGULAR_MATRIX: 'Invalid argument: Received a non lower-triangular matrix',\n  INVALID_EXPONENT: 'Invalid argument: Expected a non-negative integer exponent',\n  INVALID_ROW_COL: 'Invalid argument: Expected non-negative integer row and column',\n  INVALID_ROW: 'Invalid argument: Expected non-negative integer row',\n  INVALID_COLUMN: 'Invalid argument: Expected non-negative integer column',\n  INVALID_ROWS_EXPRESSION: 'Invalid argument: Received invalid rows expression',\n  INVALID_COLUMNS_EXPRESSION: 'Invalid argument: Received invalid columns expression',\n  INVALID_P_NORM: 'Invalid argument: Received invalid p-norm',\n  OVERFLOW_INDEX: 'Invalid argument: Matrix index overflow',\n  OVERFLOW_COLUMN: 'Invalid argument: Column index overflow',\n  OVERFLOW_ROW: 'Invalid argument: Row index overflow',\n  NO_UNIQUE_SOLUTION: 'Arithmetic Exception: The system has no unique solution',\n  SIZE_INCOMPATIBLE: 'Invalid argument: Matrix size-incompatible',\n  SINGULAR_MATRIX: 'Arithmetic Exception: The matrix is not invertible',\n  EXPECTED_STRING_NUMBER_AT_POS_1_2: 'Invalid argument: Expected a string or a number at arguments[1] and arguments[2]',\n  EXPECTED_ARRAY_OF_NUMBERS_OR_MATRICES: 'Invalid argument: Expected either an array of numbers or an array of square matrices'\n};","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX;\n/**\r\n * Calculates the LUP decomposition of the Matrix,\r\n * where L is lower triangular matrix which diagonal entries are always 1,\r\n * U is upper triangular matrix, and P is permutation matrix.<br><br>\r\n * \r\n * It is implemented using Gaussian Elimination with Partial Pivoting in order to\r\n * reduce the error caused by floating-point arithmetic.<br><br>\r\n * \r\n * Note that if optimized is true, P is a Permutation Array and both L and U are merged\r\n * into one matrix in order to improve performance.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} A - Any matrix\r\n * @param {boolean} [optimized=false] - Returns [P, LU] if it is true, [P, L, U] if it is false\r\n * @returns {Matrix[]} The LUP decomposition of Matrix\r\n */\n\n\nfunction LU(A) {\n  var optimized = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n  if (!(A instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  var _A$size = A.size(),\n      _A$size2 = _slicedToArray(_A$size, 2),\n      row = _A$size2[0],\n      col = _A$size2[1];\n\n  var size = Math.min(row, col);\n  var EPSILON = 1 / (Math.pow(10, A._digit) * 2);\n  var permutation = initPermutation(row);\n\n  var copy = this.clone(A)._matrix;\n\n  for (var i = 0; i < row - 1; i++) {\n    var currentCol = Math.min(i, col); // apply Partial Pivoting\n\n    PartialPivoting(copy, permutation, currentCol, row, col);\n    var ith = permutation[i];\n    var pivot = copy[ith][currentCol];\n\n    if (Math.abs(pivot) < EPSILON) {\n      continue;\n    }\n\n    for (var j = i + 1; j < row; j++) {\n      var jth = permutation[j];\n      var entry = copy[jth][currentCol];\n\n      if (Math.abs(entry) >= EPSILON) {\n        var factor = entry / pivot;\n\n        for (var k = currentCol; k < col; k++) {\n          copy[jth][k] -= factor * copy[ith][k];\n        }\n\n        copy[jth][currentCol] = factor;\n      }\n    }\n  }\n\n  var result = new Array(row);\n\n  for (var _i2 = 0; _i2 < row; _i2++) {\n    result[_i2] = copy[permutation[_i2]];\n  }\n\n  if (optimized) {\n    return [permutation, new this(result)];\n  }\n\n  var P = this.generate(row, row, function (i, j) {\n    var idx = permutation[i];\n\n    if (j === idx) {\n      return 1;\n    }\n\n    return 0;\n  });\n  var L = this.generate(row, size, function (i, j) {\n    if (i === j) {\n      return 1;\n    }\n\n    if (i < j) {\n      return 0;\n    }\n\n    return result[i][j];\n  });\n  var U = this.generate(size, col, function (i, j) {\n    if (i > j) {\n      return 0;\n    }\n\n    return result[i][j];\n  });\n  return [P, L, U];\n}\n\n;\n\nfunction initPermutation(size) {\n  var permutation = new Array(size);\n\n  for (var i = 0; i < size; i++) {\n    permutation[i] = i;\n  }\n\n  return permutation;\n}\n\nfunction PartialPivoting(matrix, permutation, pos, row, col) {\n  var currentCol = Math.min(pos, col);\n  var maxIdx = pos;\n  var max = Math.abs(matrix[permutation[pos]][currentCol]);\n\n  for (var i = pos + 1; i < row; i++) {\n    var value = Math.abs(matrix[permutation[i]][currentCol]);\n\n    if (value > max) {\n      maxIdx = i;\n      max = value;\n    }\n  }\n\n  var t = permutation[pos];\n  permutation[pos] = permutation[maxIdx];\n  permutation[maxIdx] = t;\n}\n\nmodule.exports = LU;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX;\n/**\r\n * Calculates the QR decomposition of the Matrix\r\n * where Q is orthogonal matrix, R is upper triangular matrix.<br><br>\r\n * \r\n * The algorithm is implemented using Householder Transform instead of Gram–Schmidt process\r\n * because the Householder Transform is more numerically stable.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} A - Any matrix\r\n * @returns {Matrix[]} The QR decomposition of matrix in the form of [Q, R]\r\n */\n\n\nfunction QR(A) {\n  if (!(A instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  var _A$size = A.size(),\n      _A$size2 = _slicedToArray(_A$size, 2),\n      row = _A$size2[0],\n      col = _A$size2[1];\n\n  var size = Math.min(row, col);\n  var EPSILON = 1 / (Math.pow(10, A._digit) * 2);\n\n  var matrixR = this.clone(A)._matrix;\n\n  var matrixQ = this.identity(row)._matrix;\n\n  for (var j = 0; j < size; j++) {\n    // if all entries below main diagonal are considered as zero, skip this round\n    var skip = true;\n\n    for (var i = j + 1; i < row; i++) {\n      if (Math.abs(matrixR[i][j]) >= EPSILON) {\n        skip = false;\n        break;\n      }\n    }\n\n    if (!skip) {\n      // Apply Householder transform\n      var norm = 0;\n\n      for (var _i2 = j; _i2 < row; _i2++) {\n        norm += Math.pow(matrixR[_i2][j], 2);\n      }\n\n      norm = Math.sqrt(norm); // reduce floating point arithmatic error\n\n      var s = -1;\n\n      if (matrixR[j][j] < 0) {\n        s = 1;\n      }\n\n      var u1 = matrixR[j][j] - s * norm;\n      var w = new Array(row - j);\n\n      for (var _i3 = 0; _i3 < row - j; _i3++) {\n        w[_i3] = matrixR[_i3 + j][j] / u1;\n      }\n\n      w[0] = 1;\n      var tau = -1 * s * u1 / norm;\n      var subR = new Array(row - j);\n\n      for (var _i4 = 0; _i4 < row - j; _i4++) {\n        var newRow = new Array(col);\n\n        for (var k = 0; k < col; k++) {\n          newRow[k] = matrixR[j + _i4][k];\n        }\n\n        subR[_i4] = newRow;\n      }\n\n      for (var _i5 = j; _i5 < row; _i5++) {\n        for (var _k = 0; _k < col; _k++) {\n          var summation = 0;\n\n          for (var m = 0; m < row - j; m++) {\n            summation += subR[m][_k] * w[m];\n          }\n\n          matrixR[_i5][_k] = subR[_i5 - j][_k] - tau * w[_i5 - j] * summation;\n        }\n      }\n\n      var subQ = new Array(row);\n\n      for (var _i6 = 0; _i6 < row; _i6++) {\n        var _newRow = new Array(row - j);\n\n        for (var _k2 = 0; _k2 < row - j; _k2++) {\n          _newRow[_k2] = matrixQ[_i6][j + _k2];\n        }\n\n        subQ[_i6] = _newRow;\n      }\n\n      for (var _i7 = 0; _i7 < row; _i7++) {\n        for (var _k3 = j; _k3 < row; _k3++) {\n          var _summation = 0;\n\n          for (var _m = 0; _m < row - j; _m++) {\n            _summation += subQ[_i7][_m] * w[_m];\n          }\n\n          matrixQ[_i7][_k3] = subQ[_i7][_k3 - j] - tau * w[_k3 - j] * _summation;\n        }\n      }\n    }\n  }\n\n  for (var _i8 = 0; _i8 < row; _i8++) {\n    for (var _j = 0; _j < col; _j++) {\n      if (_i8 > _j) {\n        matrixR[_i8][_j] = 0;\n      }\n    }\n  }\n\n  return [new this(matrixQ), new this(matrixR)];\n}\n\n;\nmodule.exports = QR;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar empty = require('../../util/empty');\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX,\n    INVALID_UPPER_TRIANGULAR_MATRIX = _require.INVALID_UPPER_TRIANGULAR_MATRIX,\n    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX,\n    SIZE_INCOMPATIBLE = _require.SIZE_INCOMPATIBLE,\n    NO_UNIQUE_SOLUTION = _require.NO_UNIQUE_SOLUTION;\n/**\r\n* Solve system of linear equations Ux = y using backward substitution,\r\n* where U is an upper triangular matrix.\r\n* If there is no unique solutions, an error is thrown.\r\n* @memberof Matrix\r\n* @static\r\n* @param {Matrix} U - Any n x n upper triangular Matrix\r\n* @param {Matrix} y - Any n x 1 Matrix\r\n* @returns {Matrix} n x 1 Matrix which is the solution of Ux = y\r\n*/\n\n\nfunction backward(U, y) {\n  if (!(U instanceof this) || !(y instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  if (!U.isUpperTriangular()) {\n    throw new Error(INVALID_UPPER_TRIANGULAR_MATRIX);\n  }\n\n  if (!U.isSquare()) {\n    throw new Error(INVALID_SQUARE_MATRIX);\n  }\n\n  var size = U.size()[0];\n\n  var _y$size = y.size(),\n      _y$size2 = _slicedToArray(_y$size, 2),\n      yrow = _y$size2[0],\n      ycol = _y$size2[1];\n\n  var matrixU = U._matrix;\n  var matrixY = y._matrix;\n\n  if (yrow !== size || ycol !== 1) {\n    throw new Error(SIZE_INCOMPATIBLE);\n  }\n\n  var EPSILON = 1 / (Math.pow(10, U._digit) * 2);\n\n  for (var i = 0; i < size; i++) {\n    if (Math.abs(matrixU[i][i]) < EPSILON) {\n      throw new Error(NO_UNIQUE_SOLUTION);\n    }\n  }\n\n  var coefficients = empty(size, 1);\n\n  for (var _i2 = size - 1; _i2 >= 0; _i2--) {\n    var summation = 0;\n\n    for (var j = _i2 + 1; j < size; j++) {\n      summation += coefficients[j][0] * matrixU[_i2][j];\n    }\n\n    coefficients[_i2][0] = (matrixY[_i2][0] - summation) / matrixU[_i2][_i2];\n  }\n\n  return new this(coefficients);\n}\n\n;\nmodule.exports = backward;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar empty = require('../../util/empty');\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX,\n    INVALID_LOWER_TRIANGULAR_MATRIX = _require.INVALID_LOWER_TRIANGULAR_MATRIX,\n    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX,\n    SIZE_INCOMPATIBLE = _require.SIZE_INCOMPATIBLE,\n    NO_UNIQUE_SOLUTION = _require.NO_UNIQUE_SOLUTION;\n/**\r\n * Solve system of linear equations Lx = y using forward substitution,\r\n * where L is a lower triangular matrix.\r\n * If there is no unique solutions, an error is thrown.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} L - Any n x n lower triangular Matrix\r\n * @param {Matrix} y - Any n x 1 Matrix\r\n * @returns {Matrix} n x 1 Matrix which is the solution of Lx = y\r\n */\n\n\nfunction forward(L, y) {\n  if (!(L instanceof this) || !(y instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  if (!L.isLowerTriangular()) {\n    throw new Error(INVALID_LOWER_TRIANGULAR_MATRIX);\n  }\n\n  if (!L.isSquare()) {\n    throw new Error(INVALID_SQUARE_MATRIX);\n  }\n\n  var size = L.size()[0];\n\n  var _y$size = y.size(),\n      _y$size2 = _slicedToArray(_y$size, 2),\n      yrow = _y$size2[0],\n      ycol = _y$size2[1];\n\n  var matrixL = L._matrix;\n  var matrixY = y._matrix;\n\n  if (size !== yrow || ycol !== 1) {\n    throw new Error(SIZE_INCOMPATIBLE);\n  }\n\n  var EPSILON = 1 / (Math.pow(10, L._digit) * 2);\n\n  for (var i = 0; i < size; i++) {\n    if (Math.abs(matrixL[i][i]) < EPSILON) {\n      throw new Error(NO_UNIQUE_SOLUTION);\n    }\n  }\n\n  var coefficients = empty(size, 1);\n\n  for (var _i2 = 0; _i2 < size; _i2++) {\n    var summation = 0;\n\n    for (var j = 0; j < _i2; j++) {\n      summation += coefficients[j][0] * matrixL[_i2][j];\n    }\n\n    coefficients[_i2][0] = (matrixY[_i2][0] - summation) / matrixL[_i2][_i2];\n  }\n\n  return new this(coefficients);\n}\n\n;\nmodule.exports = forward;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX,\n    NO_UNIQUE_SOLUTION = _require.NO_UNIQUE_SOLUTION,\n    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX,\n    SIZE_INCOMPATIBLE = _require.SIZE_INCOMPATIBLE;\n/**\r\n * Solve system of linear equations Ax = y using LU decomposition.\r\n * If there is no unique solutions, an error is thrown.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} L - Any n x n square Matrix\r\n * @param {Matrix} y - Any n x 1 Matrix\r\n * @returns {Matrix} n x 1 Matrix which is the solution of Ax = y\r\n */\n\n\nfunction solve(A, b) {\n  if (!(A instanceof this) || !(b instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  if (!A.isSquare()) {\n    throw new Error(INVALID_SQUARE_MATRIX);\n  }\n\n  var _A$size = A.size(),\n      _A$size2 = _slicedToArray(_A$size, 2),\n      aRow = _A$size2[0],\n      aCol = _A$size2[1];\n\n  var _b$size = b.size(),\n      _b$size2 = _slicedToArray(_b$size, 2),\n      bRow = _b$size2[0],\n      bCol = _b$size2[1];\n\n  if (aCol !== bRow || bCol !== 1) {\n    throw new Error(SIZE_INCOMPATIBLE);\n  }\n\n  var EPSILON = 1 / (Math.pow(10, A._digit) * 2);\n\n  var _this$LU = this.LU(A, true),\n      _this$LU2 = _slicedToArray(_this$LU, 2),\n      P = _this$LU2[0],\n      LU = _this$LU2[1];\n\n  var matrixLU = LU._matrix;\n  var matrixB = b._matrix;\n\n  for (var i = aRow - 1; i >= 0; i--) {\n    if (Math.abs(matrixLU[i][i]) < EPSILON) {\n      throw new Error(NO_UNIQUE_SOLUTION);\n    }\n  }\n\n  var clonedVector = new Array(bRow);\n  var coefficients = new Array(bRow);\n\n  for (var _i2 = 0; _i2 < bRow; _i2++) {\n    // eslint-disable-next-line prefer-destructuring\n    clonedVector[_i2] = matrixB[P[_i2]][0];\n  }\n\n  for (var _i3 = 0; _i3 < aRow; _i3++) {\n    var summation = 0;\n\n    for (var j = 0; j < _i3; j++) {\n      summation += coefficients[j] * matrixLU[_i3][j];\n    }\n\n    coefficients[_i3] = clonedVector[_i3] - summation;\n  }\n\n  for (var _i4 = aRow - 1; _i4 >= 0; _i4--) {\n    var _summation = 0;\n\n    for (var _j = _i4 + 1; _j < aRow; _j++) {\n      _summation += matrixLU[_i4][_j] * clonedVector[_j];\n    }\n\n    clonedVector[_i4] = (coefficients[_i4] - _summation) / matrixLU[_i4][_i4];\n  }\n\n  for (var _i5 = 0; _i5 < bRow; _i5++) {\n    coefficients[_i5] = [clonedVector[_i5]];\n  }\n\n  return new this(coefficients);\n}\n\n;\nmodule.exports = solve;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX,\n    SIZE_INCOMPATIBLE = _require.SIZE_INCOMPATIBLE;\n/**\r\n * Calculates the sum of two Matrices.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} A - Any Matrix\r\n * @param {Matrix} B - Any Matrix that has same size with A\r\n * @returns {Matrix} The sum of two Matrices\r\n */\n\n\nfunction add(A, B) {\n  if (!(A instanceof this) || !(B instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  var _A$size = A.size(),\n      _A$size2 = _slicedToArray(_A$size, 2),\n      row = _A$size2[0],\n      col = _A$size2[1];\n\n  var _B$size = B.size(),\n      _B$size2 = _slicedToArray(_B$size, 2),\n      row2 = _B$size2[0],\n      col2 = _B$size2[1];\n\n  if (row !== row2 || col !== col2) {\n    throw new Error(SIZE_INCOMPATIBLE);\n  }\n\n  var matrix1 = A._matrix;\n  var matrix2 = B._matrix;\n  return this.generate(row, col, function (i, j) {\n    return matrix1[i][j] + matrix2[i][j];\n  });\n}\n\n;\nmodule.exports = add;","\"use strict\";\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX,\n    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX,\n    SINGULAR_MATRIX = _require.SINGULAR_MATRIX;\n\nvar Matrix = require('../..');\n/**\r\n * Find the inverse of non-singular matrix using Elementary Row Operations.\r\n * If the matrix is singular, an error is thrown.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} A - Any square Matrix\r\n * @returns {Matrix} The inverse of A\r\n */\n\n\nfunction inverse(A) {\n  if (!(A instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  if (!A.isSquare()) {\n    throw new Error(INVALID_SQUARE_MATRIX);\n  }\n\n  var size = A.size()[0];\n\n  if (size === 0) {\n    // inverse of 0x0 matrix is itself\n    return new Matrix([]);\n  }\n\n  var EPSILON = 1 / (Math.pow(10, A._digit) * 2);\n\n  var inv = this.identity(size)._matrix;\n\n  var clone = this.clone(A)._matrix;\n\n  var permutation = initPermutation(size); // iterate each column\n\n  for (var j = 0; j < size; j++) {\n    var pivotIdx = j;\n    var pivot = clone[permutation[j]][j];\n\n    while (Math.abs(pivot) < EPSILON && pivotIdx < size - 1) {\n      pivotIdx++;\n      pivot = clone[permutation[pivotIdx]][j];\n    }\n\n    if (Math.abs(pivot) < EPSILON) {\n      throw new Error(SINGULAR_MATRIX);\n    }\n\n    if (j !== pivotIdx) {\n      var temp = permutation[j];\n      permutation[j] = permutation[pivotIdx];\n      permutation[pivotIdx] = temp;\n    }\n\n    var pivotRow = permutation[j]; // the pivot is guaranteed to be non-zero\n\n    for (var i = 0; i < size; i++) {\n      var ith = permutation[i];\n\n      if (i === j) {\n        for (var k = 0; k < size; k++) {\n          if (k === j) {\n            clone[ith][k] = 1;\n          }\n\n          if (k > j) {\n            clone[ith][k] /= pivot;\n          }\n\n          inv[ith][k] /= pivot;\n        }\n\n        pivot = 1;\n      }\n\n      if (i !== j && Math.abs(clone[ith][j]) >= EPSILON) {\n        var factor = clone[ith][j] / pivot;\n\n        for (var _k = 0; _k < size; _k++) {\n          if (_k === j) {\n            clone[ith][_k] = 0;\n          }\n\n          if (_k > j) {\n            clone[ith][_k] -= factor * clone[pivotRow][_k];\n          }\n\n          inv[ith][_k] -= factor * inv[pivotRow][_k];\n        }\n      }\n    }\n  }\n\n  for (var _i = 0; _i < size; _i++) {\n    clone[_i] = inv[permutation[_i]];\n  }\n\n  return new this(clone);\n}\n\n;\n\nfunction initPermutation(size) {\n  var permutation = new Array(size);\n\n  for (var i = 0; i < size; i++) {\n    permutation[i] = i;\n  }\n\n  return permutation;\n}\n\nmodule.exports = inverse;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar empty = require('../../util/empty');\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX,\n    SIZE_INCOMPATIBLE = _require.SIZE_INCOMPATIBLE;\n/**\r\n * Calculates the product of two Matrices.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} A - Any Matrix\r\n * @param {Matrix} B - Any Matrix that is size-compatible with A\r\n * @returns {Matrix} The product of two Matrices\r\n */\n\n\nfunction multiply(A, B) {\n  if (!(A instanceof this) || !(B instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  var _A$size = A.size(),\n      _A$size2 = _slicedToArray(_A$size, 2),\n      Arow = _A$size2[0],\n      Acol = _A$size2[1];\n\n  var _B$size = B.size(),\n      _B$size2 = _slicedToArray(_B$size, 2),\n      Brow = _B$size2[0],\n      Bcol = _B$size2[1];\n\n  if (Acol !== Brow) {\n    throw new Error(SIZE_INCOMPATIBLE);\n  }\n\n  var matrixA = A._matrix;\n  var matrixB = B._matrix;\n  var result = empty(Arow, Bcol);\n\n  for (var i = 0; i < Arow; i++) {\n    for (var j = 0; j < Bcol; j++) {\n      result[i][j] = 0;\n\n      for (var k = 0; k < Brow; k++) {\n        result[i][j] += matrixA[i][k] * matrixB[k][j];\n      }\n    }\n  }\n\n  return new this(result);\n}\n\n;\nmodule.exports = multiply;","\"use strict\";\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX,\n    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX,\n    INVALID_EXPONENT = _require.INVALID_EXPONENT;\n/**\r\n * Calculates the power of any square matrix.\r\n * The algorithm is implemented recursively.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} A - Any square Matrix\r\n * @param {number} exponent - Any Non-negative integer\r\n * @returns {Matrix} The power of A\r\n */\n\n\nfunction pow(A, exponent) {\n  if (!(A instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  if (!A.isSquare()) {\n    throw new Error(INVALID_SQUARE_MATRIX);\n  }\n\n  if (!Number.isInteger(exponent) || exponent < 0) {\n    throw new Error(INVALID_EXPONENT);\n  }\n\n  var size = A.size()[0];\n\n  if (exponent === 0) {\n    return this.identity(size);\n  }\n\n  if (exponent === 1) {\n    return this.clone(A);\n  }\n\n  if (exponent % 2 === 0) {\n    var _temp = this.pow(A, exponent / 2);\n\n    return this.multiply(_temp, _temp);\n  }\n\n  var temp = this.pow(A, (exponent - 1) / 2);\n  return this.multiply(this.multiply(temp, temp), A);\n}\n\n;\nmodule.exports = pow;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar _require = require('../../Error'),\n    SIZE_INCOMPATIBLE = _require.SIZE_INCOMPATIBLE,\n    INVALID_MATRIX = _require.INVALID_MATRIX;\n/**\r\n * Calculates the difference of two Matrices.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} A - Any Matrix\r\n * @param {Matrix} B - Any Matrix that has same size with A\r\n * @returns {Matrix} The difference of two Matrices\r\n */\n\n\nmodule.exports = function subtract(A, B) {\n  if (!(A instanceof this) || !(B instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  var _A$size = A.size(),\n      _A$size2 = _slicedToArray(_A$size, 2),\n      row = _A$size2[0],\n      col = _A$size2[1];\n\n  var _B$size = B.size(),\n      _B$size2 = _slicedToArray(_B$size, 2),\n      row2 = _B$size2[0],\n      col2 = _B$size2[1];\n\n  if (row !== row2 || col !== col2) {\n    throw new Error(SIZE_INCOMPATIBLE);\n  }\n\n  var matrix1 = A._matrix;\n  var matrix2 = B._matrix;\n  return this.generate(row, col, function (i, j) {\n    return matrix1[i][j] - matrix2[i][j];\n  });\n};","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX;\n/**\r\n * Find the transpose of a matrix.\r\n * @memberof Matrix\r\n * @static\r\n * @param { Matrix } A - Any Matrix\r\n * @returns { Matrix } Returns transpose of A\r\n */\n\n\nfunction transpose(A) {\n  if (!(A instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  var _A$size = A.size(),\n      _A$size2 = _slicedToArray(_A$size, 2),\n      row = _A$size2[0],\n      col = _A$size2[1];\n\n  var matrix = A._matrix;\n  return this.generate(col, row, function (i, j) {\n    return matrix[j][i];\n  });\n}\n\n;\nmodule.exports = transpose;","\"use strict\";\n\nvar Matrix = require('../..');\n\nvar _require = require('../../Error'),\n    INVALID_P_NORM = _require.INVALID_P_NORM,\n    SINGULAR_MATRIX = _require.SINGULAR_MATRIX,\n    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX;\n/**\r\n * Calculations the condition number of square Matrix\r\n * with respect to the choice of Matrix norm. \r\n * If the Matrix is singular, returns Infinity.<br><br>\r\n * The condition number is not cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @param {(1|2|Infinity|'F')} p - Type of Matrix norm\r\n * @returns {number} The condition number of Matrix\r\n */\n\n\nfunction cond() {\n  var p = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 2;\n\n  if (p !== 1 && p !== 2 && p !== Infinity && p !== 'F') {\n    throw new Error(INVALID_P_NORM);\n  }\n\n  if (!this.isSquare()) {\n    throw new Error(INVALID_SQUARE_MATRIX);\n  }\n\n  try {\n    var inverse = Matrix.inverse(this);\n    return inverse.norm(p) * this.norm(p);\n  } catch (error) {\n    if (error.message === SINGULAR_MATRIX) {\n      return Infinity;\n    }\n\n    throw error;\n  }\n}\n\n;\nmodule.exports = cond;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\n/* eslint-disable prefer-destructuring */\nvar Matrix = require('../..');\n\nvar _require = require('../../Error'),\n    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX;\n/**\r\n * Calculates the determinant of square Matrix.\r\n * If the Matrix size is larger than 3, it calculates the determinant using\r\n * LU decomposition, otherwise, using Leibniz Formula.<br><br>\r\n * The determinant is cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @returns {number} Returns the determinant of square matrirx\r\n */\n\n\nfunction det() {\n  if (!this.isSquare()) {\n    throw new Error(INVALID_SQUARE_MATRIX);\n  }\n\n  if (this._det !== undefined) {\n    return this._det;\n  }\n\n  var matrix = this._matrix;\n  var size = matrix.length;\n\n  if (size === 0) {\n    this._det = 1;\n    return 1; // the determinant of 0x0 matrix must be 1\n  }\n\n  if (size === 1) {\n    this._det = matrix[0][0];\n    return this._det;\n  }\n\n  if (size === 2) {\n    this._det = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];\n    return this._det;\n  }\n\n  if (size === 3) {\n    this._det = matrix[0][0] * matrix[1][1] * matrix[2][2] + matrix[0][1] * matrix[1][2] * matrix[2][0] + matrix[0][2] * matrix[1][0] * matrix[2][1] - matrix[0][2] * matrix[1][1] * matrix[2][0] - matrix[0][1] * matrix[1][0] * matrix[2][2] - matrix[0][0] * matrix[1][2] * matrix[2][1];\n    return this._det;\n  }\n\n  var _Matrix$LU = Matrix.LU(this, true),\n      _Matrix$LU2 = _slicedToArray(_Matrix$LU, 2),\n      P = _Matrix$LU2[0],\n      LU = _Matrix$LU2[1];\n\n  var matrixLU = LU._matrix; // count whether the number of permutations <swap> is odd or even\n  // O(n^2)\n\n  var swap = 0;\n\n  for (var i = 0; i < size; i++) {\n    if (P[i] === i) {\n      continue;\n    }\n\n    while (P[i] !== i) {\n      var target = P[i];\n      P[i] = P[target];\n      P[target] = target;\n      swap++;\n    }\n  }\n\n  var result = 1;\n\n  for (var _i2 = 0; _i2 < size; _i2++) {\n    result *= matrixLU[_i2][_i2];\n  }\n\n  if (swap % 2 === 1) {\n    this._det = result * -1;\n    return this._det;\n  }\n\n  this._det = result;\n  return result;\n}\n\n;\nmodule.exports = det;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\n/* eslint-disable no-param-reassign */\n// reference: https://people.inf.ethz.ch/arbenz/ewp/Lnotes/chapter4.pdf\nvar Complex = require('@rayyamhk/complex');\n\nvar Matrix = require('../..');\n\nvar _require = require('../../Error'),\n    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX;\n/**\r\n * Calculates the eigenvalues of any square Matrix using QR Algorithm.<br><br>\r\n * \r\n * The eigenvalues can be either real number or complex number.\r\n * Note that all eigenvalues are instance of Complex,\r\n * for more details please visit [Complex.js]{@link https://github.com/rayyamhk/Complex.js}.<br><br>\r\n * \r\n * The eigenvalues are cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @returns {Complex[]} Array of eigenvalues\r\n */\n\n\nfunction eigenvalues() {\n  if (!this.isSquare()) {\n    throw new Error(INVALID_SQUARE_MATRIX);\n  }\n\n  if (this._eigenvalues !== undefined) {\n    return this._eigenvalues;\n  }\n\n  var size = this.size()[0];\n  var values = [];\n  var digit = this._digit;\n  var EPSILON = 1 / (Math.pow(10, digit) * 2);\n\n  var clone = Matrix.clone(this)._matrix;\n\n  var isConvergent = true; // flag\n\n  var skip = false; // Transform matrix to Hessenberg matrix\n\n  HouseholderTransform(clone, digit);\n\n  for (var i = size - 1; i > 0; i--) {\n    var divergenceCount = 0;\n    var prev = void 0; // used to determine convergence\n    // if obtains complex eigenvalues pair in previous iteration, skip current round\n\n    if (skip) {\n      skip = false;\n      continue;\n    }\n\n    var shift = clone[size - 1][size - 1]; // eslint-disable-next-line no-constant-condition\n\n    while (true) {\n      if (!isConvergent) {\n        // if the current eigenvalue is not real\n        prev = size2Eigenvalues(clone[i - 1][i - 1], clone[i - 1][i], clone[i][i - 1], clone[i][i]).metric;\n      } else {\n        // if the current eigenvalue is real\n        prev = Math.abs(clone[i][i - 1]);\n      } // apply single shift\n\n\n      for (var j = 0; j < size; j++) {\n        clone[j][j] -= shift;\n      } // Apply QR Algorithm\n\n\n      HessenbergQR(clone, digit);\n\n      for (var _j = 0; _j < size; _j++) {\n        clone[_j][_j] += shift;\n      }\n\n      if (isConvergent && prev < Math.abs(clone[i][i - 1])) {\n        divergenceCount++;\n      } // if the current eigenvalue is real and the entry is almost ZERO => break;\n\n\n      if (isConvergent && Math.abs(clone[i][i - 1]) < EPSILON) {\n        values[i] = new Complex(clone[i][i]);\n        break;\n      } // if the current eigenvalues pair is complex, if the difference of the previous eiganvalues and the\n      // eigenvalues of submatrix is almost ZERO => break\n\n\n      var _size2Eigenvalues = size2Eigenvalues(clone[i - 1][i - 1], clone[i - 1][i], clone[i][i - 1], clone[i][i]),\n          metric = _size2Eigenvalues.metric,\n          eigen1 = _size2Eigenvalues.eigen1,\n          eigen2 = _size2Eigenvalues.eigen2;\n\n      if (!isConvergent && Math.abs(prev - metric) < EPSILON) {\n        isConvergent = true; // re-initialize\n\n        skip = true;\n        var re1 = eigen1.re,\n            im1 = eigen1.im;\n        var re2 = eigen2.re,\n            im2 = eigen2.im;\n        values[i] = new Complex(re1, im1);\n        values[i - 1] = new Complex(re2, im2);\n        break;\n      } // if the entry doesn't converge => complex eigenvalues pair\n\n\n      if (divergenceCount > 3) {\n        isConvergent = false;\n      }\n    }\n  }\n\n  if (!skip) {\n    values[0] = new Complex(clone[0][0]);\n  }\n\n  this._eigenvalues = values;\n  return values;\n}\n\n;\n\nfunction HouseholderTransform(A, digit) {\n  var size = A.length;\n  var EPSILON = 1 / (Math.pow(10, digit) * 2);\n\n  for (var j = 0; j < size - 2; j++) {\n    var xNorm = 0;\n    var u = new Array(size - j - 1);\n\n    for (var i = j + 1; i < size; i++) {\n      var entry = A[i][j];\n      xNorm += Math.pow(entry, 2);\n      u[i - j - 1] = entry;\n    }\n\n    xNorm = Math.sqrt(xNorm);\n\n    if (Math.abs(xNorm) < EPSILON) {\n      continue;\n    }\n\n    if (u[0] >= 0) {\n      u[0] += xNorm;\n    } else {\n      u[0] -= xNorm;\n    } // Make 'u' unit vector\n\n\n    var uNorm = 0;\n\n    for (var _i = 0; _i < u.length; _i++) {\n      uNorm += Math.pow(u[_i], 2);\n    }\n\n    uNorm = Math.sqrt(uNorm);\n\n    for (var _i2 = 0; _i2 < u.length; _i2++) {\n      u[_i2] /= uNorm;\n    } // update the matrix, multiply P from left\n\n\n    for (var n = j; n < size; n++) {\n      // column\n      var v = new Array(size - j - 1);\n\n      for (var m = j + 1; m < size; m++) {\n        v[m - j - 1] = A[m][n];\n      }\n\n      var scaler = 0;\n\n      for (var _m = 0; _m < v.length; _m++) {\n        scaler += v[_m] * u[_m];\n      }\n\n      scaler *= 2;\n\n      for (var _m2 = j + 1; _m2 < size; _m2++) {\n        // row\n        if (n === j && _m2 !== j + 1) {\n          A[_m2][n] = 0;\n        } else {\n          A[_m2][n] = v[_m2 - j - 1] - scaler * u[_m2 - j - 1];\n        }\n      }\n    } // update the matrix, multiply P from right\n\n\n    for (var _m3 = 0; _m3 < size; _m3++) {\n      // row\n      var _v = new Array(size - j - 1);\n\n      for (var _n = j + 1; _n < size; _n++) {\n        _v[_n - j - 1] = A[_m3][_n];\n      }\n\n      var _scaler = 0;\n\n      for (var _n2 = 0; _n2 < _v.length; _n2++) {\n        _scaler += _v[_n2] * u[_n2];\n      }\n\n      _scaler *= 2;\n\n      for (var _n3 = j + 1; _n3 < size; _n3++) {\n        // column\n        A[_m3][_n3] = _v[_n3 - j - 1] - _scaler * u[_n3 - j - 1];\n      }\n    }\n  }\n}\n\nfunction HessenbergQR(H, digit) {\n  var size = H.length;\n  var EPSILON = 1 / (Math.pow(10, digit) * 2);\n  var sincos = new Array(size - 1);\n\n  for (var i = 0; i < size - 1; i++) {\n    var a = H[i][i];\n    var c = H[i + 1][i];\n    var norm = Math.sqrt(Math.pow(a, 2) + Math.pow(c, 2));\n\n    if (norm < EPSILON) {\n      continue;\n    }\n\n    var cos = a / norm;\n    var sin = c * -1 / norm;\n    sincos[i] = [sin, cos];\n    var row1 = new Array(size - i);\n    var row2 = new Array(size - i);\n\n    for (var j = i; j < size; j++) {\n      row1[j - i] = H[i][j];\n      row2[j - i] = H[i + 1][j];\n    }\n\n    for (var _j2 = i; _j2 < size; _j2++) {\n      H[i][_j2] = cos * row1[_j2 - i] + sin * -1 * row2[_j2 - i];\n\n      if (i === _j2) {\n        H[i + 1][_j2] = 0;\n      } else {\n        H[i + 1][_j2] = sin * row1[_j2 - i] + cos * row2[_j2 - i];\n      }\n    }\n  }\n\n  for (var _j3 = 0; _j3 < size - 1; _j3++) {\n    if (!sincos[_j3]) {\n      continue;\n    }\n\n    var _sincos$_j = _slicedToArray(sincos[_j3], 2),\n        _sin = _sincos$_j[0],\n        _cos = _sincos$_j[1];\n\n    var col1 = new Array(_j3 + 2);\n    var col2 = new Array(_j3 + 2);\n\n    for (var _i3 = 0; _i3 <= _j3 + 1; _i3++) {\n      col1[_i3] = H[_i3][_j3];\n      col2[_i3] = H[_i3][_j3 + 1];\n    }\n\n    for (var _i4 = 0; _i4 <= _j3 + 1; _i4++) {\n      H[_i4][_j3] = col1[_i4] * _cos - col2[_i4] * _sin;\n      H[_i4][_j3 + 1] = col1[_i4] * _sin + col2[_i4] * _cos;\n    }\n  }\n} // find the eigenvalues of 2x2 matrix\n\n\nfunction size2Eigenvalues(e11, e12, e21, e22) {\n  var b = (e11 + e22) * -1;\n  var c = e11 * e22 - e21 * e12;\n  var delta = Math.pow(b, 2) - 4 * c;\n  var re1;\n  var im1;\n  var re2;\n  var im2;\n\n  if (delta >= 0) {\n    im1 = 0;\n    im2 = 0;\n\n    if (b >= 0) {\n      re1 = (b * -1 - Math.sqrt(delta)) / 2;\n    } else {\n      re1 = (b * -1 + Math.sqrt(delta)) / 2;\n    }\n\n    re2 = c / re1;\n  } else {\n    re1 = -b / 2;\n    re2 = re1;\n    im1 = Math.sqrt(delta * -1) / 2;\n    im2 = im1 * -1;\n  }\n\n  return {\n    metric: Math.sqrt(Math.pow(re1, 2) + Math.pow(im1, 2)),\n    eigen1: {\n      re: re1,\n      im: im1\n    },\n    eigen2: {\n      re: re2,\n      im: im2\n    }\n  };\n}\n\nmodule.exports = eigenvalues;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar Matrix = require('../..');\n\nvar _require = require('../../Error'),\n    INVALID_P_NORM = _require.INVALID_P_NORM;\n/**\r\n * Calculates the Matrix norm of any Matrix with respect to the choice of norm.<br><br>\r\n * \r\n * 1-norm: Maximum absolute column sum of the Matrix.<br>\r\n * 2-norm: The largest singular value of Matrix.<br>\r\n * Infinity-norm: Maximum absolute row sum of the Matrix.<br>\r\n * Frobenius-norm: Euclidean norm invloving all entries.<br><br>\r\n * \r\n * The norms are not cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @param {(1|2|Infinity|'F')} p - The choice of Matrix norm\r\n * @returns {number} The norm of the Matrix.\r\n */\n\n\nfunction norm() {\n  var p = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 2;\n\n  var _this$size = this.size(),\n      _this$size2 = _slicedToArray(_this$size, 2),\n      row = _this$size2[0],\n      col = _this$size2[1];\n\n  if (p !== 1 && p !== 2 && p !== Infinity && p !== 'F') {\n    throw new Error(INVALID_P_NORM);\n  }\n\n  var matrix = this._matrix;\n  var result = 0;\n\n  if (p === 1) {\n    // max of column sum\n    for (var j = 0; j < col; j++) {\n      var columnSum = 0;\n\n      for (var i = 0; i < row; i++) {\n        columnSum += Math.abs(matrix[i][j]);\n      }\n\n      if (columnSum > result) {\n        result = columnSum;\n      }\n    }\n\n    return result;\n  } // largest singular value\n\n\n  if (p === 2) {\n    var transpose = Matrix.transpose(this);\n    var M = Matrix.multiply(transpose, this);\n    var eigenvalues = M.eigenvalues();\n\n    for (var _i2 = 0; _i2 < eigenvalues.length; _i2++) {\n      var value = eigenvalues[_i2].getModulus();\n\n      if (value > result) {\n        result = value;\n      }\n    }\n\n    return Math.sqrt(result);\n  }\n\n  if (p === Infinity) {\n    // max of row sum\n    for (var _i3 = 0; _i3 < row; _i3++) {\n      var rowSum = 0;\n\n      for (var _j = 0; _j < col; _j++) {\n        rowSum += Math.abs(matrix[_i3][_j]);\n      }\n\n      if (rowSum > result) {\n        result = rowSum;\n      }\n    }\n\n    return result;\n  } // F\n\n\n  for (var _i4 = 0; _i4 < row; _i4++) {\n    for (var _j2 = 0; _j2 < col; _j2++) {\n      result += Math.pow(matrix[_i4][_j2], 2);\n    }\n  }\n\n  return Math.sqrt(result);\n}\n\n;\nmodule.exports = norm;","\"use strict\";\n\n/**\r\n * Calculates the nullity of any Matrix, which is the dimension\r\n * of the nullspace.<br><br>\r\n * \r\n * The nullity is cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @returns {number} The nullity of the matrix\r\n */\nfunction nullity() {\n  if (this._nullity !== undefined) {\n    return this._nullity;\n  }\n\n  var col = this.size()[1];\n  var rank = this.rank();\n  this._nullity = col - rank;\n  return this._nullity;\n}\n\n;\nmodule.exports = nullity;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar Matrix = require('../..');\n/**\r\n * Calculates the rank of any Matrix,\r\n * which is the dimension of the row space.<br><br>\r\n * \r\n * The rank is cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @returns {number} The rank of the Matrix\r\n */\n\n\nfunction rank() {\n  if (this._rank !== undefined) {\n    return this._rank;\n  }\n\n  var EPSILON = 1 / (Math.pow(10, this._digit) * 2);\n  var R = Matrix.QR(this)[1];\n  var matrixR = R._matrix;\n\n  var _R$size = R.size(),\n      _R$size2 = _slicedToArray(_R$size, 2),\n      row = _R$size2[0],\n      col = _R$size2[1];\n\n  if (row === 0) {\n    this._rank = 1;\n    return 1;\n  }\n\n  var rk = 0;\n\n  for (var i = 0; i < row; i++) {\n    for (var j = i; j < col; j++) {\n      if (Math.abs(matrixR[i][j]) >= EPSILON) {\n        rk++;\n        break;\n      }\n    }\n  }\n\n  this._rank = rk;\n  return rk;\n}\n\n;\nmodule.exports = rank;","\"use strict\";\n\n/**\r\n * Calculates the size of any Matrix,\r\n * which is in the form of [row, column].<br><br>\r\n * \r\n * The size of Matrix is cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @returns {number[]} The number of rows and columns of a Matrix\r\n */\nfunction size() {\n  if (this._size !== undefined) {\n    return this._size;\n  }\n\n  var A = this._matrix;\n\n  if (A.length === 0) {\n    this._size = [0, 0];\n    return this._size;\n  }\n\n  this._size = [A.length, A[0].length];\n  return this._size;\n}\n\n;\nmodule.exports = size;","\"use strict\";\n\nvar _require = require('../../Error'),\n    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX;\n/**\r\n * Calculates the trace of any square Matrix,\r\n * which is the sum of all entries on the main diagonal.<br><br>\r\n * \r\n * The trace is cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @returns {number} The trace of the square Matrix.\r\n */\n\n\nfunction trace() {\n  var isSquare = this._isSquare !== undefined ? this._isSquare : this.isSquare();\n\n  if (!isSquare) {\n    throw new Error(INVALID_SQUARE_MATRIX);\n  }\n\n  if (this._trace !== undefined) {\n    return this._trace;\n  }\n\n  var A = this._matrix;\n  var size = A.length;\n  var tr = 0;\n\n  for (var i = 0; i < size; i++) {\n    tr += A[i][i];\n  }\n\n  this._trace = tr;\n  return tr;\n}\n\n;\nmodule.exports = trace;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\n/**\r\n * Determines whether a Matrix is diagonal or not.<br><br>\r\n * \r\n * Diagonal Matrix is a Matrix in which the entries outside the main diagonal\r\n * are all zero. Note that the term diagonal refers to rectangular diagonal.<br><br>\r\n * \r\n * The result is cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @param {number} [digit=8] - Number of significant digits\r\n * @returns {boolean} Returns rue if the Matrix is diagonal Matrix\r\n */\nfunction isDiagonal() {\n  var digit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._digit;\n\n  if (this._isDiagonal !== undefined) {\n    return this._isDiagonal;\n  }\n\n  var EPSILON = 1 / (Math.pow(10, digit) * 2);\n  var A = this._matrix;\n\n  var _this$size = this.size(),\n      _this$size2 = _slicedToArray(_this$size, 2),\n      row = _this$size2[0],\n      col = _this$size2[1];\n\n  if (row === 0) {\n    this._isDiagonal = true;\n    return true;\n  }\n\n  for (var i = 0; i < row; i++) {\n    for (var j = 0; j < col; j++) {\n      if (i !== j && Math.abs(A[i][j]) >= EPSILON) {\n        this.isDiagonal = false;\n        return false;\n      }\n    }\n  }\n\n  this._isDiagonal = true;\n  return true;\n}\n\n;\nmodule.exports = isDiagonal;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\n/**\r\n * Determines whether a Matrix is lower triangular Matrix or not.<br><br>\r\n * \r\n * Lower triangular Matrix is a Matrix in which all the entries\r\n * above the main diagonal are zero. Note that it can be applied\r\n * to any non-square Matrix.<br><br>\r\n * \r\n * The result is cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @param {number} [digit=8] - Number of significant digits\r\n * @returns {boolean} Returns true if the Matrix is lower triangular\r\n */\nfunction isLowerTriangular() {\n  var digit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._digit;\n\n  if (this._isLowerTriangular !== undefined) {\n    return this._isLowerTriangular;\n  }\n\n  var EPSILON = 1 / (Math.pow(10, digit) * 2);\n  var A = this._matrix;\n\n  var _this$size = this.size(),\n      _this$size2 = _slicedToArray(_this$size, 2),\n      row = _this$size2[0],\n      col = _this$size2[1];\n\n  if (row === 0) {\n    // []\n    this._isLowerTriangular = true;\n    return true;\n  }\n\n  for (var i = 0; i < row; i++) {\n    for (var j = i + 1; j < col; j++) {\n      if (Math.abs(A[i][j]) >= EPSILON) {\n        this._isLowerTriangular = false;\n        return false;\n      }\n    }\n  }\n\n  this._isLowerTriangular = true;\n  return true;\n}\n\n;\nmodule.exports = isLowerTriangular;","\"use strict\";\n\n/**\r\n * Determines whether a square Matrix is orthogonal or not.<br><br>\r\n * \r\n * Orthogonal Matrix is a Matrix in which all rows and columns are\r\n * orthonormal vectors.<br><br>\r\n * \r\n * The result is cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @param {number} [digit=8] - Number of significant digits\r\n * @returns {boolean} Returns true if the square Matrix is orthogonal\r\n */\nfunction isOrthogonal() {\n  var digit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._digit;\n\n  if (this._isOrthogonal !== undefined) {\n    return this._isOrthogonal;\n  }\n\n  if (!this.isSquare()) {\n    this._isOrthogonal = false;\n    return false;\n  }\n\n  var A = this._matrix;\n  var EPSILON = 1 / (Math.pow(10, digit) * 2);\n  var size = A.length;\n\n  for (var i = 0; i < size; i++) {\n    for (var j = i; j < size; j++) {\n      var entry = 0;\n\n      for (var k = 0; k < size; k++) {\n        entry += A[i][k] * A[j][k];\n      }\n\n      if (i === j && Math.abs(entry - 1) >= EPSILON) {\n        this._isOrthogonal = false;\n        return false;\n      }\n\n      if (i !== j && Math.abs(entry) >= EPSILON) {\n        this._isOrthogonal = false;\n        return false;\n      }\n    }\n  }\n\n  this._isOrthogonal = true;\n  return true;\n}\n\n;\nmodule.exports = isOrthogonal;","\"use strict\";\n\n/**\r\n * Determines whether a square Matrix is skew symmetric or not.<br><br>\r\n * \r\n * Skew symmetric Matrix is a square Matrix whose transpose equals its negative.<br><br>\r\n * \r\n * The result is cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @param {number} [digit=8] - Number of significant digits\r\n * @returns {boolean} Returns true if the square Matrix is skew symmetric\r\n */\nfunction isSkewSymmetric() {\n  var digit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._digit;\n\n  if (this._isSkewSymmetric !== undefined) {\n    return this._isSkewSymmetric;\n  }\n\n  if (!this.isSquare()) {\n    this._isSkewSymmetric = false;\n    return false;\n  }\n\n  var A = this._matrix;\n  var EPSILON = 1 / (Math.pow(10, digit) * 2);\n  var size = A.length;\n\n  if (size === 0) {\n    this._isSkewSymmetric = true;\n    return true; // []\n  }\n\n  for (var i = 0; i < size; i++) {\n    for (var j = 0; j < i; j++) {\n      if (Math.abs(A[i][j] + A[j][i]) >= EPSILON) {\n        this._isSkewSymmetric = false;\n        return false;\n      }\n    }\n  }\n\n  this._isSkewSymmetric = true;\n  return true;\n}\n\n;\nmodule.exports = isSkewSymmetric;","\"use strict\";\n\n/**\r\n * Determines whether a Matrix is square or not.<br><br>\r\n * \r\n * Square Matrix is a Matrix with same number of rows and columns.<br><br>\r\n * \r\n * The result is cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @returns {boolean} Returns true if the Matrix is square\r\n */\nfunction isSquare() {\n  if (this._isSquare !== undefined) {\n    return this._isSquare;\n  }\n\n  var A = this._matrix;\n\n  if (A.length === 0) {\n    // 0x0 matrix\n    this._isSquare = true;\n    return true;\n  }\n\n  this._isSquare = A.length === A[0].length;\n  return this._isSquare;\n}\n\n;\nmodule.exports = isSquare;","\"use strict\";\n\n/**\r\n * Determines whether a square Matrix is symmetric or not.<br><br>\r\n * \r\n * Symmetric Matrix is a square Matrix that is equal to its transpose.<br><br>\r\n * \r\n * The result is cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @param {number} [digit=8] - Number of significant digits\r\n * @returns {boolean} Returns true if the square Matrix is symmetric\r\n */\nfunction isSymmetric() {\n  var digit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._digit;\n\n  if (this._isSymmetric !== undefined) {\n    return this._isSymmetric;\n  }\n\n  if (!this.isSquare()) {\n    return false;\n  }\n\n  var A = this._matrix;\n  var EPSILON = 1 / (Math.pow(10, digit) * 2);\n  var size = A.length;\n\n  for (var i = 0; i < size; i++) {\n    for (var j = 0; j <= i; j++) {\n      if (Math.abs(A[i][j] - A[j][i]) >= EPSILON) {\n        this._isSymmetric = false;\n        return false;\n      }\n    }\n  }\n\n  this._isSymmetric = true;\n  return true;\n}\n\n;\nmodule.exports = isSymmetric;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\n/**\r\n * Determines whether a Matrix is upper triangular Matrix or not.<br><br>\r\n * \r\n * Upper triangular Matrix is a Matrix in which all the entries below the\r\n * main diagonal are zero. Note that it can be applied to any non-square Matrix.<br><br>\r\n *  \r\n * The result is cached.\r\n * @memberof Matrix\r\n * @instance\r\n * @param {number} [digit=8] - Number of significant digits\r\n * @returns {boolean} Returns true if the Matrix is upper triangular\r\n */\nfunction isUpperTriangular() {\n  var digit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._digit;\n\n  if (this._isUpperTriangular !== undefined) {\n    return this._isUpperTriangular;\n  }\n\n  var EPSILON = 1 / (Math.pow(10, digit) * 2);\n  var A = this._matrix;\n\n  var _this$size = this.size(),\n      _this$size2 = _slicedToArray(_this$size, 2),\n      row = _this$size2[0],\n      col = _this$size2[1];\n\n  if (row === 0) {\n    // []\n    this._isUpperTriangular = true;\n    return true;\n  }\n\n  for (var i = 0; i < row; i++) {\n    for (var j = 0; j < col; j++) {\n      if (i <= j) {\n        continue;\n      }\n\n      if (Math.abs(A[i][j]) >= EPSILON) {\n        this._isUpperTriangular = false;\n        return false;\n      }\n    }\n  }\n\n  this._isUpperTriangular = true;\n  return true;\n}\n\n;\nmodule.exports = isUpperTriangular;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX;\n/**\r\n * Creates a copy of Matrix. Note that it resets the cached data.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} A - Any Matrix\r\n * @returns {Matrix} Copy of A\r\n */\n\n\nfunction clone(A) {\n  if (!(A instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  var _A$size = A.size(),\n      _A$size2 = _slicedToArray(_A$size, 2),\n      row = _A$size2[0],\n      col = _A$size2[1];\n\n  var matrix = A._matrix;\n  return this.generate(row, col, function (i, j) {\n    return matrix[i][j];\n  });\n}\n\n;\nmodule.exports = clone;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar _require = require('../../Error'),\n    INVALID_ROW_COL = _require.INVALID_ROW_COL,\n    OVERFLOW_COLUMN = _require.OVERFLOW_COLUMN,\n    INVALID_MATRIX = _require.INVALID_MATRIX;\n/**\r\n * Gets the column of a Matrix with valid index.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} A - Any Matrix\r\n * @param {number} index - Any valid column index\r\n * @returns {Matrix} Column of A\r\n */\n\n\nfunction column(A, index) {\n  if (!(A instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  if (!Number.isInteger(index) || index < 0) {\n    throw new Error(INVALID_ROW_COL);\n  }\n\n  var _A$size = A.size(),\n      _A$size2 = _slicedToArray(_A$size, 2),\n      r = _A$size2[0],\n      c = _A$size2[1];\n\n  if (index >= c) {\n    throw new Error(OVERFLOW_COLUMN);\n  }\n\n  var matrix = A._matrix;\n  return this.generate(r, 1, function (i) {\n    return matrix[i][index];\n  });\n}\n\n;\nmodule.exports = column;","\"use strict\";\n\nvar Matrix = require('../..');\n\nvar isNumber = require('../../util/isNumber');\n\nvar _require = require('../../Error'),\n    INVALID_ARRAY = _require.INVALID_ARRAY,\n    EXPECTED_ARRAY_OF_NUMBERS_OR_MATRICES = _require.EXPECTED_ARRAY_OF_NUMBERS_OR_MATRICES,\n    INVALID_SQUARE_MATRIX = _require.INVALID_SQUARE_MATRIX;\n/**\r\n * Generates diagonal Matrix if the argument is an array of numbers,\r\n * generates block diagonal Matrix if the argument is an array of Matrices.\r\n * @memberof Matrix\r\n * @static\r\n * @param {(number[]|Matrix[])} values - Array of numbers or Matrices\r\n * @returns {Matrix} Block diagonal Matrix\r\n */\n\n\nfunction diag(values) {\n  if (!Array.isArray(values)) {\n    throw new Error(INVALID_ARRAY);\n  }\n\n  var argsNum = values.length;\n  var variant;\n\n  for (var i = 0; i < argsNum; i++) {\n    var entry = values[i];\n\n    if (!isNumber(entry) && !(entry instanceof Matrix)) {\n      throw new Error(EXPECTED_ARRAY_OF_NUMBERS_OR_MATRICES);\n    }\n\n    if (isNumber(entry)) {\n      if (!variant) {\n        variant = 'number';\n        continue;\n      }\n\n      if (variant !== 'number') {\n        throw new Error(EXPECTED_ARRAY_OF_NUMBERS_OR_MATRICES);\n      }\n    } else {\n      if (!entry.isSquare()) {\n        throw new Error(INVALID_SQUARE_MATRIX);\n      }\n\n      if (!variant) {\n        variant = 'square';\n        continue;\n      }\n\n      if (variant !== 'square') {\n        throw new Error(EXPECTED_ARRAY_OF_NUMBERS_OR_MATRICES);\n      }\n    }\n  } // HERE: variant should be either 'number' or 'square'\n\n\n  if (variant === 'number') {\n    return Matrix.generate(argsNum, argsNum, function (i, j) {\n      if (i === j) {\n        return values[i];\n      }\n\n      return 0;\n    });\n  } // Guaranteed that [values] is a list of square matrices\n\n\n  var size = 0;\n  var temp = new Array(argsNum);\n\n  for (var _i = 0; _i < argsNum; _i++) {\n    var _len = values[_i].size()[0];\n\n    size += _len;\n    temp[_i] = _len;\n  }\n\n  var idx = 0;\n  var start = 0;\n  var len = temp[idx];\n  return Matrix.generate(size, size, function (i, j) {\n    if (i - start === len && j - start === len) {\n      start += len;\n      idx++;\n    }\n\n    var ith = i - start; // ith < 0 if below main diagonal\n\n    var jth = j - start; // jth < 0 if above main diagonal\n    // skip 0x0 matrices\n\n    len = temp[idx];\n\n    while (len === 0) {\n      idx++;\n      len = temp[idx];\n    }\n\n    if (ith < len && ith >= 0 && jth < len && jth >= 0) {\n      return values[idx]._matrix[ith][jth];\n    }\n\n    return 0;\n  });\n}\n\n;\nmodule.exports = diag;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX;\n/**\r\n * This callback applies on each entry of a Matrix\r\n * @callback entryCallback\r\n * @param {number} entry - Entry of a Matrix\r\n * @returns {number} New entry value\r\n */\n\n/**\r\n * Applys a function over each entry of a Matrix and returns\r\n * a new copy of the new Matrix.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} A - Any Matrix\r\n * @param {entryCallback} cb - Callback function which applies on each entry of A\r\n * @returns {Matrix} A copy of new Matrix\r\n */\n\n\nfunction elementwise(A, cb) {\n  if (!(A instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  var _A$size = A.size(),\n      _A$size2 = _slicedToArray(_A$size, 2),\n      row = _A$size2[0],\n      col = _A$size2[1];\n\n  var matrix = A._matrix;\n  return this.generate(row, col, function (i, j) {\n    return cb(matrix[i][j]);\n  });\n}\n\n;\nmodule.exports = elementwise;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar _require = require('../../Error'),\n    INVALID_ROW_COL = _require.INVALID_ROW_COL,\n    OVERFLOW_INDEX = _require.OVERFLOW_INDEX;\n/**\r\n * Gets the entry of a Matrix.\r\n * @memberof Matrix\r\n * @instance\r\n * @param {number} row - Any valid row index\r\n * @param {number} col - Any valid column index\r\n * @returns {number} Entry of the Matrix\r\n */\n\n\nfunction entry(row, col) {\n  if (!Number.isInteger(row) || row < 0 || !Number.isInteger(col) || col < 0) {\n    throw new Error(INVALID_ROW_COL);\n  }\n\n  var A = this._matrix;\n\n  var _this$size = this.size(),\n      _this$size2 = _slicedToArray(_this$size, 2),\n      r = _this$size2[0],\n      c = _this$size2[1];\n\n  if (row >= r || col >= c) {\n    throw new Error(OVERFLOW_INDEX);\n  }\n\n  return A[row][col];\n}\n\n;\nmodule.exports = entry;","\"use strict\";\n\nvar empty = require('../../util/empty');\n/**\r\n * This callback generates each entry of a Matrix\r\n * @callback generateCallback\r\n * @param {number} i - The i-th row of Matrix \r\n * @param {number} j - The j-th column of Matrix \r\n * @returns {number} Entry of Matrix\r\n */\n\n/**\r\n * Generates a Matrix which entries are the returned value of callback function.\r\n * @memberof Matrix\r\n * @static\r\n * @param {number} row - Number of rows of Matrix\r\n * @param {number} col - Number of columns of Matrix\r\n * @param {generateCallback} cb - Callback function which takes row and column as arguments\r\n * and generates the corresponding entry\r\n * @returns {Matrix} - Generated Matrix\r\n */\n\n\nfunction generate(row, col, cb) {\n  var matrix = empty(row, col);\n\n  if (row === 0 || col === 0) {\n    return new this([]);\n  }\n\n  for (var i = 0; i < row; i++) {\n    for (var j = 0; j < col; j++) {\n      matrix[i][j] = cb(i, j);\n    }\n  }\n\n  return new this(matrix);\n}\n\n;\nmodule.exports = generate;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX;\n/**\r\n * Gets the entries on the main diagonal.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} A - Any Matrix\r\n * @returns {number[]} Array of entries of A on the main diagonal\r\n */\n\n\nfunction getDiag(A) {\n  if (!(A instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  var _A$size = A.size(),\n      _A$size2 = _slicedToArray(_A$size, 2),\n      row = _A$size2[0],\n      col = _A$size2[1];\n\n  var size = Math.min(row, col);\n  var matrix = A._matrix;\n  var diags = new Array(size);\n\n  for (var i = 0; i < size; i++) {\n    diags[i] = matrix[i][i];\n  }\n\n  return diags;\n}\n\n;\nmodule.exports = getDiag;","\"use strict\";\n\n/**\r\n * Generates a random Matrix.\r\n * @memberof Matrix\r\n * @static\r\n * @param {number} row - Number of rows of a Matrix\r\n * @param {number} col - Number of columns of a Matrix\r\n * @param {number} min - Lower bound of each entry\r\n * @param {number} max - Upper bound of each entry\r\n * @param {number} toFixed - Number of decimal places\r\n * @returns {Matrix} Generated random Matrix\r\n */\nfunction getRandomMatrix(row, col) {\n  var min = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n  var max = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;\n  var toFixed = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;\n  return this.generate(row, col, function () {\n    return Number.parseFloat((Math.random() * (max - min) + min).toFixed(toFixed));\n  });\n}\n\n;\nmodule.exports = getRandomMatrix;","\"use strict\";\n\n/**\r\n * Generates identity Matrix with given size.\r\n * @memberof Matrix\r\n * @static\r\n * @param {number} size - The size of Matrix\r\n * @returns {Matrix} Identity Matrix\r\n */\nfunction identity(size) {\n  return this.generate(size, size, function (i, j) {\n    if (i === j) {\n      return 1;\n    }\n\n    return 0;\n  });\n}\n\n;\nmodule.exports = identity;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX;\n/**\r\n * Determines whether two Matrices are considered as equal.<br><br>\r\n * \r\n * The test criterion is Math.abs(x - y) < 1 / (10 ** digit * 2).\r\n * For default value 5, it should be 5e-5.\r\n * That means if the difference of two numbers is less than 5e-5,\r\n * they are considered as same value.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} A - Any Matrix\r\n * @param {Matrix} B - Any Matrix\r\n * @param {number} digit - Number of significant digits\r\n * @returns {boolean} Returns true if two Matrices are considered as same\r\n */\n\n\nfunction isEqual(A, B) {\n  var digit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 5;\n\n  if (!(A instanceof this) || !(B instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  var _A$size = A.size(),\n      _A$size2 = _slicedToArray(_A$size, 2),\n      Arow = _A$size2[0],\n      Acol = _A$size2[1];\n\n  var _B$size = B.size(),\n      _B$size2 = _slicedToArray(_B$size, 2),\n      Brow = _B$size2[0],\n      Bcol = _B$size2[1];\n\n  if (Arow !== Brow || Acol !== Bcol) {\n    return false;\n  }\n\n  var EPISILON = 1 / (Math.pow(10, digit) * 2);\n  var matrixA = A._matrix;\n  var matrixB = B._matrix;\n\n  for (var i = 0; i < Arow; i++) {\n    for (var j = 0; j < Acol; j++) {\n      if (Math.abs(matrixA[i][j] - matrixB[i][j]) >= EPISILON) {\n        return false;\n      }\n    }\n  }\n\n  return true;\n}\n\n;\nmodule.exports = isEqual;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar _require = require('../../Error'),\n    INVALID_ROW_COL = _require.INVALID_ROW_COL,\n    OVERFLOW_ROW = _require.OVERFLOW_ROW,\n    INVALID_MATRIX = _require.INVALID_MATRIX;\n/**\r\n * Gets the row of a Matrix with valid index.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} A - Any Matrix\r\n * @param {number} index - Any valid row index\r\n * @returns {Matrix} Row of A\r\n */\n\n\nfunction row(A, index) {\n  if (!(A instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  if (!Number.isInteger(index) || index < 0) {\n    throw new Error(INVALID_ROW_COL);\n  }\n\n  var _A$size = A.size(),\n      _A$size2 = _slicedToArray(_A$size, 2),\n      r = _A$size2[0],\n      c = _A$size2[1];\n\n  if (index >= r) {\n    throw new Error(OVERFLOW_ROW);\n  }\n\n  var matrix = A._matrix;\n  return this.generate(1, c, function (i, j) {\n    return matrix[index][j];\n  });\n}\n\n;\nmodule.exports = row;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nvar _require = require('../../Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX,\n    EXPECTED_STRING_NUMBER_AT_POS_1_2 = _require.EXPECTED_STRING_NUMBER_AT_POS_1_2,\n    INVALID_ROW = _require.INVALID_ROW,\n    INVALID_COLUMN = _require.INVALID_COLUMN,\n    OVERFLOW_ROW = _require.OVERFLOW_ROW,\n    INVALID_ROWS_EXPRESSION = _require.INVALID_ROWS_EXPRESSION,\n    INVALID_COLUMNS_EXPRESSION = _require.INVALID_COLUMNS_EXPRESSION,\n    OVERFLOW_COLUMN = _require.OVERFLOW_COLUMN;\n/**\r\n * Generates a submatrix of a matrix.\r\n * @memberof Matrix\r\n * @static\r\n * @param {Matrix} A - Any matrix\r\n * @param {string|number} rows - Rows expression\r\n * @param {string|number} cols - Columns expression\r\n * @returns {Matrix} Submatrix of A\r\n */\n\n\nfunction submatrix(A, rows, cols) {\n  if (!(A instanceof this)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  var arg1Type = _typeof(rows);\n\n  var arg2Type = _typeof(cols);\n\n  if (arg1Type !== 'string' && arg1Type !== 'number' || arg2Type !== 'string' && arg2Type !== 'number') {\n    throw new Error(EXPECTED_STRING_NUMBER_AT_POS_1_2);\n  }\n\n  var _A$size = A.size(),\n      _A$size2 = _slicedToArray(_A$size, 2),\n      row = _A$size2[0],\n      col = _A$size2[1];\n\n  var rowStart;\n  var rowEnd;\n  var colStart;\n  var colEnd;\n\n  if (arg1Type === 'number') {\n    if (!Number.isInteger(rows) || rows < 0) {\n      throw new Error(INVALID_ROW);\n    }\n\n    if (rows >= row) {\n      throw new Error(OVERFLOW_ROW);\n    }\n\n    rowStart = rows;\n    rowEnd = rows;\n  } else {\n    // string\n    var arg = rows.split(':');\n\n    if (arg.length !== 2) {\n      throw new Error(INVALID_ROWS_EXPRESSION);\n    }\n\n    var _arg = _slicedToArray(arg, 2),\n        r1 = _arg[0],\n        r2 = _arg[1];\n\n    if (r1 === '') {\n      rowStart = 0;\n    } else {\n      var r = Number(r1);\n\n      if (!Number.isInteger(r) || r < 0) {\n        throw new Error(INVALID_ROW);\n      }\n\n      if (r >= row) {\n        throw new Error(OVERFLOW_ROW);\n      }\n\n      rowStart = r;\n    }\n\n    if (r2 === '') {\n      rowEnd = row - 1;\n    } else {\n      var _r = Number(r2);\n\n      if (!Number.isInteger(_r) || _r < 0) {\n        throw new Error(INVALID_ROW);\n      }\n\n      if (_r >= row) {\n        throw new Error(OVERFLOW_ROW);\n      }\n\n      rowEnd = _r;\n    }\n\n    if (rowStart > rowEnd) {\n      throw new Error(INVALID_ROWS_EXPRESSION);\n    }\n  }\n\n  if (arg2Type === 'number') {\n    if (!Number.isInteger(cols) || cols < 0) {\n      throw new Error(INVALID_COLUMN);\n    }\n\n    if (cols >= col) {\n      throw new Error(OVERFLOW_COLUMN);\n    }\n\n    colStart = cols;\n    colEnd = cols;\n  } else {\n    // string\n    var _arg2 = cols.split(':');\n\n    if (_arg2.length !== 2) {\n      throw new Error(INVALID_COLUMNS_EXPRESSION);\n    }\n\n    var _arg3 = _slicedToArray(_arg2, 2),\n        c1 = _arg3[0],\n        c2 = _arg3[1];\n\n    if (c1 === '') {\n      colStart = 0;\n    } else {\n      var c = Number(c1);\n\n      if (!Number.isInteger(c) || c < 0) {\n        throw new Error(INVALID_COLUMN);\n      }\n\n      if (c >= col) {\n        throw new Error(OVERFLOW_COLUMN);\n      }\n\n      colStart = c;\n    }\n\n    if (c2 === '') {\n      colEnd = col - 1;\n    } else {\n      var _c = Number(c2);\n\n      if (!Number.isInteger(_c) || _c < 0) {\n        throw new Error(INVALID_COLUMN);\n      }\n\n      if (_c >= col) {\n        throw new Error(OVERFLOW_COLUMN);\n      }\n\n      colEnd = _c;\n    }\n\n    if (colStart > colEnd) {\n      throw new Error(INVALID_COLUMNS_EXPRESSION);\n    }\n  }\n\n  var matrix = A._matrix;\n  var subRow = rowEnd - rowStart + 1;\n  var subCol = colEnd - colStart + 1;\n  var subMatrix = new Array(subRow);\n\n  for (var i = rowStart; i <= rowEnd; i++) {\n    var newRow = new Array(subCol);\n\n    for (var j = colStart; j <= colEnd; j++) {\n      newRow[j - colStart] = matrix[i][j];\n    }\n\n    subMatrix[i - rowStart] = newRow;\n  }\n\n  return new this(subMatrix);\n}\n\n;\nmodule.exports = submatrix;","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\n/**\r\n * Gets the stringified Matrix\r\n * @memberof Matrix\r\n * @instance\r\n * @returns {string} Stringified Matrix\r\n */\nfunction toString() {\n  var matrix = this._matrix;\n\n  var _this$size = this.size(),\n      _this$size2 = _slicedToArray(_this$size, 2),\n      row = _this$size2[0],\n      col = _this$size2[1];\n\n  var str = '';\n\n  for (var i = 0; i < row; i++) {\n    for (var j = 0; j < col; j++) {\n      str += matrix[i][j].toString();\n\n      if (j !== col - 1) {\n        str += ' ';\n      }\n    }\n\n    if (i !== row - 1) {\n      str += '\\n';\n    }\n  }\n\n  return str;\n}\n\n;\nmodule.exports = toString;","\"use strict\";\n\n/**\r\n * Generates a zero Matrix\r\n * @memberof Matrix\r\n * @static\r\n * @param {number} row - Number of rows of the Matrix\r\n * @param {number} col - Number of columns of the Matrix\r\n * @returns {Matrix} Zero Matrix\r\n */\nfunction zero(row, col) {\n  if (col === undefined) {\n    return this.generate(row, row, function () {\n      return 0;\n    });\n  }\n\n  return this.generate(row, col, function () {\n    return 0;\n  });\n}\n\n;\nmodule.exports = zero;","\"use strict\";\n\nvar isMatrix = require('./util/isMatrix');\n\nvar _require = require('./Error'),\n    INVALID_MATRIX = _require.INVALID_MATRIX;\n/**\r\n * Creates a new Matrix\r\n * @namespace Matrix\r\n * @class\r\n * @param {number[][]} A - Two dimensional array where\r\n * A[i][j] represents the i-th row and j-th column of a matrix\r\n */\n\n\nfunction Matrix(A) {\n  if (!isMatrix(A)) {\n    throw new Error(INVALID_MATRIX);\n  }\n\n  this._matrix = A;\n  this._digit = 8;\n}\n\nmodule.exports = Matrix; // structure\n\nMatrix.prototype.isDiagonal = require('./core/structure/isDiagonal');\nMatrix.prototype.isSkewSymmetric = require('./core/structure/isSkewSymmetric');\nMatrix.prototype.isSquare = require('./core/structure/isSquare');\nMatrix.prototype.isSymmetric = require('./core/structure/isSymmetric');\nMatrix.prototype.isLowerTriangular = require('./core/structure/isLowerTriangular');\nMatrix.prototype.isUpperTriangular = require('./core/structure/isUpperTriangular');\nMatrix.prototype.isOrthogonal = require('./core/structure/isOrthogonal'); // property\n\nMatrix.prototype.cond = require('./core/properties/cond');\nMatrix.prototype.det = require('./core/properties/det');\nMatrix.prototype.eigenvalues = require('./core/properties/eigenvalues');\nMatrix.prototype.nullity = require('./core/properties/nullity');\nMatrix.prototype.norm = require('./core/properties/norm');\nMatrix.prototype.rank = require('./core/properties/rank');\nMatrix.prototype.size = require('./core/properties/size');\nMatrix.prototype.trace = require('./core/properties/trace'); // operations\n\nMatrix.add = require('./core/operations/add');\nMatrix.inverse = require('./core/operations/inverse');\nMatrix.multiply = require('./core/operations/multiply');\nMatrix.pow = require('./core/operations/pow');\nMatrix.subtract = require('./core/operations/subtract');\nMatrix.transpose = require('./core/operations/transpose'); // Linear-equations\n\nMatrix.backward = require('./core/linear-equations/backward');\nMatrix.forward = require('./core/linear-equations/forward');\nMatrix.solve = require('./core/linear-equations/solve'); // decompositions\n\nMatrix.LU = require('./core/decompositions/LU');\nMatrix.QR = require('./core/decompositions/QR'); // utils\n\nMatrix.clone = require('./core/utils/clone');\nMatrix.column = require('./core/utils/column');\nMatrix.diag = require('./core/utils/diag');\nMatrix.elementwise = require('./core/utils/elementwise');\nMatrix.generate = require('./core/utils/generate');\nMatrix.getDiag = require('./core/utils/getDiag');\nMatrix.getRandomMatrix = require('./core/utils/getRandomMatrix');\nMatrix.identity = require('./core/utils/identity');\nMatrix.isEqual = require('./core/utils/isEqual');\nMatrix.row = require('./core/utils/row');\nMatrix.submatrix = require('./core/utils/submatrix');\nMatrix.zero = require('./core/utils/zero');\nMatrix.prototype.entry = require('./core/utils/entry');\nMatrix.prototype.toString = require('./core/utils/toString');","\"use strict\";\n\nvar _require = require('../Error'),\n    INVALID_ROW_COL = _require.INVALID_ROW_COL;\n\nmodule.exports = function empty(row, col) {\n  if (!Number.isInteger(row) || row < 0 || !Number.isInteger(col) || col < 0) {\n    throw new Error(INVALID_ROW_COL);\n  }\n\n  if (row === 0 || col === 0) {\n    return [];\n  }\n\n  var matrix = new Array(row);\n\n  for (var i = 0; i < row; i++) {\n    matrix[i] = new Array(col);\n  }\n\n  return matrix;\n};","\"use strict\";\n\nvar isNumber = require('./isNumber');\n\nmodule.exports = function isMatrix(matrix) {\n  if (!Array.isArray(matrix)) {\n    return false;\n  }\n\n  var height = matrix.length;\n\n  if (height === 0) {\n    return true; // [] represents empty matrix (0 x 0 matrix)\n  }\n\n  var firstRow = matrix[0];\n\n  if (!Array.isArray(firstRow)) {\n    return false;\n  }\n\n  var width = firstRow.length;\n\n  if (width === 0) {\n    return false; // [ [] ] is not allowed\n  }\n\n  for (var i = 0; i < height; i++) {\n    var row = matrix[i];\n\n    if (!Array.isArray(row) || row.length !== width) {\n      return false;\n    }\n\n    for (var j = 0; j < width; j++) {\n      if (!isNumber(row[j])) {\n        return false;\n      }\n    }\n  }\n\n  return true;\n};","\"use strict\";\n\nmodule.exports = function isNumber(_int) {\n  return Number.isFinite(_int);\n};","var Sylvester = {}\n\nSylvester.Matrix = function () {}\n\nSylvester.Matrix.create = function (elements) {\n  var M = new Sylvester.Matrix()\n  return M.setElements(elements)\n}\n\nSylvester.Matrix.I = function (n) {\n  var els = [],\n    i = n,\n    j\n  while (i--) {\n    j = n\n    els[i] = []\n    while (j--) {\n      els[i][j] = i === j ? 1 : 0\n    }\n  }\n  return Sylvester.Matrix.create(els)\n}\n\nSylvester.Matrix.prototype = {\n  dup: function () {\n    return Sylvester.Matrix.create(this.elements)\n  },\n\n  isSquare: function () {\n    var cols = this.elements.length === 0 ? 0 : this.elements[0].length\n    return this.elements.length === cols\n  },\n\n  toRightTriangular: function () {\n    if (this.elements.length === 0) return Sylvester.Matrix.create([])\n    var M = this.dup(),\n      els\n    var n = this.elements.length,\n      i,\n      j,\n      np = this.elements[0].length,\n      p\n    for (i = 0; i < n; i++) {\n      if (M.elements[i][i] === 0) {\n        for (j = i + 1; j < n; j++) {\n          if (M.elements[j][i] !== 0) {\n            els = []\n            for (p = 0; p < np; p++) {\n              els.push(M.elements[i][p] + M.elements[j][p])\n            }\n            M.elements[i] = els\n            break\n          }\n        }\n      }\n      if (M.elements[i][i] !== 0) {\n        for (j = i + 1; j < n; j++) {\n          var multiplier = M.elements[j][i] / M.elements[i][i]\n          els = []\n          for (p = 0; p < np; p++) {\n            // Elements with column numbers up to an including the number of the\n            // row that we're subtracting can safely be set straight to zero,\n            // since that's the point of this routine and it avoids having to\n            // loop over and correct rounding errors later\n            els.push(\n              p <= i ? 0 : M.elements[j][p] - M.elements[i][p] * multiplier\n            )\n          }\n          M.elements[j] = els\n        }\n      }\n    }\n    return M\n  },\n\n  determinant: function () {\n    if (this.elements.length === 0) {\n      return 1\n    }\n    if (!this.isSquare()) {\n      return null\n    }\n    var M = this.toRightTriangular()\n    var det = M.elements[0][0],\n      n = M.elements.length\n    for (var i = 1; i < n; i++) {\n      det = det * M.elements[i][i]\n    }\n    return det\n  },\n\n  isSingular: function () {\n    return this.isSquare() && this.determinant() === 0\n  },\n\n  augment: function (matrix) {\n    if (this.elements.length === 0) {\n      return this.dup()\n    }\n    var M = matrix.elements || matrix\n    if (typeof M[0][0] === 'undefined') {\n      M = Sylvester.Matrix.create(M).elements\n    }\n    var T = this.dup(),\n      cols = T.elements[0].length\n    var i = T.elements.length,\n      nj = M[0].length,\n      j\n    if (i !== M.length) {\n      return null\n    }\n    while (i--) {\n      j = nj\n      while (j--) {\n        T.elements[i][cols + j] = M[i][j]\n      }\n    }\n    return T\n  },\n\n  inverse: function () {\n    if (this.elements.length === 0) {\n      return null\n    }\n    if (!this.isSquare() || this.isSingular()) {\n      return null\n    }\n    var n = this.elements.length,\n      i = n,\n      j\n    var M = this.augment(Sylvester.Matrix.I(n)).toRightTriangular()\n    var np = M.elements[0].length,\n      p,\n      els,\n      divisor\n    var inverse_elements = [],\n      new_element\n    // Sylvester.Matrix is non-singular so there will be no zeros on the\n    // diagonal. Cycle through rows from last to first.\n    while (i--) {\n      // First, normalise diagonal elements to 1\n      els = []\n      inverse_elements[i] = []\n      divisor = M.elements[i][i]\n      for (p = 0; p < np; p++) {\n        new_element = M.elements[i][p] / divisor\n        els.push(new_element)\n        // Shuffle off the current row of the right hand side into the results\n        // array as it will not be modified by later runs through this loop\n        if (p >= n) {\n          inverse_elements[i].push(new_element)\n        }\n      }\n      M.elements[i] = els\n      // Then, subtract this row from those above it to give the identity matrix\n      // on the left hand side\n      j = i\n      while (j--) {\n        els = []\n        for (p = 0; p < np; p++) {\n          els.push(M.elements[j][p] - M.elements[i][p] * M.elements[j][i])\n        }\n        M.elements[j] = els\n      }\n    }\n    return Sylvester.Matrix.create(inverse_elements)\n  },\n\n  setElements: function (els) {\n    var i,\n      j,\n      elements = els.elements || els\n    if (elements[0] && typeof elements[0][0] !== 'undefined') {\n      i = elements.length\n      this.elements = []\n      while (i--) {\n        j = elements[i].length\n        this.elements[i] = []\n        while (j--) {\n          this.elements[i][j] = elements[i][j]\n        }\n      }\n      return this\n    }\n    var n = elements.length\n    this.elements = []\n    for (i = 0; i < n; i++) {\n      this.elements.push([elements[i]])\n    }\n    return this\n  },\n}\n\nmodule.exports = function (elements) {\n  const mat = Sylvester.Matrix.create(elements).inverse()\n  if (mat !== null) {\n    return mat.elements\n  } else {\n    return null\n  }\n}\n","module.exports = require('./lib/index.js');\n","const elemWise = require('./elem-wise');\n/**\n* Add matrixes together\n* @param {...Array.<Array.<Number>>} args list of matrix\n* @returns {Array.<Array.<Number>>} sum\n*/\nmodule.exports = function (...args) {\n\treturn elemWise(args, args2 => {\n\t\treturn args2.reduce((a, b) => {\n\t\t\tif (a === null || b === null) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\treturn a + b;\n\t\t}, 0);\n\t});\n};\n","const dotProduct = require('./dot-product.js');\nconst norm = require('./norm.js');\n\nmodule.exports = function (vector1, vector2) {\n\tif (vector1.length !== vector2.length) {\n\t\tthrow (new Error('The lengths of the vectors do not match'));\n\t}\n\n\treturn dotProduct(vector1, vector2) / (norm(vector1) * norm(vector2));\n};\n","const identity = require('./identity.js');\n\nmodule.exports = function ({blocks, order = null}) {\n\tconst dimL = blocks.map(a => a.length).reduce((a, b) => a + b, 0);\n\tconst result = identity(dimL);\n\tlet current = 0;\n\tfor (const mat of blocks) {\n\t\tfor (const [i] of mat.entries()) {\n\t\t\tfor (const [j] of mat.entries()) {\n\t\t\t\tresult[i + current][j + current] = mat[i][j];\n\t\t\t}\n\t\t}\n\n\t\tcurrent += mat.length;\n\t}\n\n\tif (order) {\n\t\treturn order.map(i => order.map(j => result[i][j]));\n\t}\n\n\treturn result;\n};\n","const zeros = require('./zeros');\n\nmodule.exports = function (mat) {\n\tconst result = zeros(mat.length, mat.length);\n\n\tfor (const [i, element] of mat.entries()) {\n\t\tresult[i][i] = element;\n\t}\n\n\treturn result;\n};\n","module.exports = function (vector1, vector2) {\n\tif (vector1.length !== vector2.length) {\n\t\tthrow (new Error('Lengths not maching'));\n\t}\n\n\tlet result = 0;\n\tfor (const [i, element] of vector1.entries()) {\n\t\tresult += element * vector2[i];\n\t}\n\n\treturn result;\n};\n","/**\n* @callback elemWiseCb\n* @param {Array.<Number>} arr\n* @param {Number} rowId\n* @param {Number} colId\n*/\n/**\n* run a function on cell per cell for each Matrixes\n* @param {<Array.<Array.<Array.<Number>>>} arrMatrixes list of matrixes\n* @param {elemWiseCb} fn\n* @returns {Array.<Array.<Number>>} resulting matrix\n* @example\n// this will do m1 + m2 + m3 + m4 on matrixes\nelemWise([m1, m2, m3, m4], args2 => {\n\treturn args2.reduce((a, b) => a + b, 0);\n});\n*/\n\nmodule.exports = function (arrayMatrixes, fn) {\n\treturn arrayMatrixes[0].map((row, rowId) => {\n\t\treturn row.map((cell, colId) => {\n\t\t\tconst array = arrayMatrixes.map(m => m[rowId][colId]);\n\t\t\treturn fn(array, rowId, colId);\n\t\t});\n\t});\n};\n\n","module.exports = function (array1, array2) {\n\tif (array1.length !== array2.length) {\n\t\tthrow new Error('Invalid array lengths');\n\t}\n\n\tconst diff = array1.map((element, index) => element - array2[index]).map(element => element * element);\n\treturn Math.sqrt(diff.reduce((a, b) => a + b));\n};\n","const trace = require('./trace.js');\nconst transpose = require('./transpose.js');\nconst matSub = require('./subtract.js');\nconst matMul = require('./mat-mul.js');\nconst sum = require('./sum.js');\n\n// [Frobenius norm](https://en.wikipedia.org/wiki/Matrix_norm#Frobenius_norm )\nmodule.exports = function (array1, array2) {\n\tif (array1 === undefined) {\n\t\treturn sum(array2);\n\t}\n\n\tif (array2 === undefined) {\n\t\treturn sum(array1);\n\t}\n\n\tconst m = matSub(array1, array2);\n\tconst p = matMul(transpose(m), m);\n\treturn Math.sqrt(trace(p));\n};\n","module.exports = function (stateSize) {\n\tconst identityArray = [];\n\tfor (let i = 0; i < stateSize; i++) {\n\t\tconst rowIdentity = [];\n\t\tfor (let j = 0; j < stateSize; j++) {\n\t\t\tif (i === j) {\n\t\t\t\trowIdentity.push(1);\n\t\t\t} else {\n\t\t\t\trowIdentity.push(0);\n\t\t\t}\n\t\t}\n\n\t\tidentityArray.push(rowIdentity);\n\t}\n\n\treturn identityArray;\n};\n","module.exports = {\n\tadd: require('./add.js'),\n\tcosSimilarity: require('./cos-similarity'),\n\teuclideanDist: require('./euclidean-dist'),\n\tdiag: require('./diag.js'),\n\tdiagBlock: require('./diag-block'),\n\tdotProduct: require('./dot-product'),\n\telemWise: require('./elem-wise.js'),\n\tfrobenius: require('./frobenius.js'),\n\tidentity: require('./identity.js'),\n\tinvert: require('./invert.js'),\n\tmapMatrix: require('./map-matrix.js'),\n\tmatMul: require('./mat-mul.js'),\n\tmatPermutation: require('./mat-permutation.js'),\n\tpadWithZeroCols: require('./pad-with-zero-cols.js'),\n\tsubtract: require('./subtract.js'),\n\tsubSquareMatrix: require('./sub-square-matrix.js'),\n\tsum: require('./sum.js'),\n\ttrace: require('./trace.js'),\n\ttranspose: require('./transpose.js'),\n\tzeros: require('./zeros.js'),\n\tnorm: require('./norm.js'),\n};\n","const matrixInverse = require('matrix-inverse');\n\nmodule.exports = function (m) {\n\treturn matrixInverse(m);\n};\n","module.exports = function (a, fn) {\n\treturn a.map((row, rowId) => row.map((cell, colId) => fn(cell, rowId, colId)));\n};\n","/**\n* Multiply 2 matrixes together\n* @param {Array.<Array.<Number>>} m1\n* @param {Array.<Array.<Number>>} m2\n* @returns {Array.<Array.<Number>>}\n*/\nmodule.exports = function (m1, m2) {\n\t// Console.log({m1, m2});\n\tconst result = [];\n\tfor (let i = 0; i < m1.length; i++) {\n\t\tresult[i] = [];\n\t\tfor (let j = 0; j < m2[0].length; j++) {\n\t\t\tlet sum = 0;\n\t\t\tlet isNull = false;\n\t\t\tfor (let k = 0; k < m1[0].length; k++) {\n\t\t\t\tif ((m1[i][k] === null && m2[k][j] !== 0) || (m2[k][j] === null && m1[i][k] !== 0)) {\n\t\t\t\t\tisNull = true;\n\t\t\t\t}\n\n\t\t\t\tsum += m1[i][k] * m2[k][j];\n\t\t\t}\n\n\t\t\tresult[i][j] = isNull ? null : sum;\n\t\t}\n\t}\n\n\treturn result;\n};\n","/**\n *\n * @param {Array.<Array.<Number>>} matrix\n * @param {[Number, Number]} outputSize\n * @param {Array.<Number>} rowIndexes the permutation indexes, result[j][k] = matrix[rowIndexes.indexOf(j)][colIndexes.indexOf(k)]\n * @param {Array.<Number>} colIndexes the permutation indexes, result[j][k] = matrix[rowIndexes.indexOf(j)][colIndexes.indexOf(k)]\n * @returns {Array.<Array.<Number>>}\n */\nmodule.exports = function ({\n\tmatrix,\n\toutputSize,\n\trowIndexes,\n\tcolIndexes,\n}) {\n\tconst [nRow, nCol] = outputSize;\n\n\tif (!Array.isArray(rowIndexes)) {\n\t\tthrow (new TypeError(`Invalid rowIndexes ${rowIndexes}`));\n\t}\n\n\tif (!Array.isArray(colIndexes)) {\n\t\tthrow (new TypeError(`Invalid colIndexes ${colIndexes}`));\n\t}\n\n\treturn new Array(nRow).fill(0).map((_, i) => new Array(nCol).fill(0).map((_, j) => {\n\t\tif (colIndexes.includes(j) && rowIndexes.includes(i)) {\n\t\t\treturn matrix[rowIndexes.indexOf(i)][colIndexes.indexOf(j)];\n\t\t}\n\n\t\treturn 0;\n\t}));\n};\n","module.exports = function (vector) {\n\tlet result = 0;\n\tfor (const element of vector) {\n\t\tresult += (element * element);\n\t}\n\n\treturn Math.sqrt(result);\n};\n","const matPermutation = require('./mat-permutation');\n/**\n*This function returns the padded matrix with zeros with respect to a given\n* target columns number\n*@param {Array.<Array.<Number>>} matrix the matrix we need to pad\n*@param {Number} columns in our case, the dynamic dimension\n*@returns {Array.<Array.<Number>>} padded matrix\n*/\nmodule.exports = function (matrix, {columns}) {\n\tif (columns < matrix[0].length) {\n\t\tthrow (new TypeError(`Output columns ${columns} is greater than input columns ${matrix[0].length}`));\n\t}\n\n\treturn matPermutation({\n\t\tmatrix,\n\t\toutputSize: [matrix.length, columns],\n\t\trowIndexes: new Array(matrix.length).fill(0).map((_, index) => index),\n\t\tcolIndexes: new Array(matrix[0].length).fill(0).map((_, index) => index),\n\t});\n};\n","module.exports = (mat, indexes) => {\n\treturn indexes.map(s1 => indexes.map(s2 => mat[s1][s2]));\n};\n","const elemWise = require('./elem-wise');\n\nmodule.exports = function (...args) {\n\treturn elemWise(args, ([a, b]) => a - b);\n};\n","// Sum all the terms of a given matrix\nmodule.exports = function (array) {\n\tlet s = 0;\n\tfor (let i = 0; i < array.length; i++) {\n\t\tfor (let j = 0; j < array.length; j++) {\n\t\t\ts += array[i][j];\n\t\t}\n\t}\n\n\treturn s;\n};\n","module.exports = function (array) {\n\tlet diag = 0;\n\tfor (const [row, element] of array.entries()) {\n\t\tdiag += element[row];\n\t}\n\n\treturn diag;\n};\n","module.exports = function (array) {\n\treturn array[0].map((col, i) => array.map(row => row[i]));\n};\n","module.exports = function (rows, cols) {\n\treturn new Array(rows).fill(1).map(() => new Array(cols).fill(0));\n};\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","","// startup\n// Load entry module and return exports\n// This entry module is referenced by other modules so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(\"./index.js\");\n",""],"names":[],"sourceRoot":""}