    /**
     * Copyright (c) 2015, Jozef Stefan Institute, Quintelligence d.o.o. and contributors
     * All rights reserved.
     *
     * This source code is licensed under the FreeBSD license found in the
     * LICENSE file in the root directory of this source tree.
     */
    /**
    * Linear algebra module.
    * @module la
    * @example
    * // import la module
    * var la = require('qminer').la;
    * // create a random matrix
    * var mat = new la.Matrix({ rows: 10, cols: 5, random: true });
    * // create a vector
    * var vec = new la.Vector([1, 2, 3, 0, -1]);
    * // multiply the matrix and vector
    * var vec2 = mat.multiply(vec);
    * // calculate the svd decomposition of the matrix
    * var svd = la.svd(mat, 3);
    */
    /**
        * Computes the truncated SVD decomposition.
        * @param {module:la.Matrix | module:la.SparseMatrix} mat - The matrix.
        * @param {number} k - The number of singular vectors to be computed.
        * @param {Object} [json] - The JSON object.
        * @param {number} [json.iter = 100] - The number of iterations used for the algorithm.
        * @param {number} [json.tol = 1e-6] - The tolerance number.
        * @param {function} [callback] - The callback function, that takes the error parameters (err) and the result parameter (res).
        * &lt;i>Only for the asynchronous function.&lt;/i>
        * @returns {Object} The JSON object `svdRes` which contains the SVD decomposition U*S*V^T matrices:
        * &lt;br>`svdRes.U` - The dense matrix of the decomposition. Type {@link module:la.Matrix}.
        * &lt;br>`svdRes.V` - The dense matrix of the decomposition. Type {@link module:la.Matrix}.
        * &lt;br>`svdRes.s` - The vector containing the singular values of the decomposition. Type {@link module:la.Vector}.
        * @example &lt;caption>Asynchronous function&lt;/caption>
        * // import the modules
        * var la = require('qminer').la;
        * // create a random matrix
        * var A = new la.Matrix({ rows: 10, cols: 5, random: true });
        * // set the parameters for the calculation
        * var k = 2; // number of singular vectors
        * var param = { iter: 1000, tol: 1e-4 };
        * // calculate the svd
        * la.svd(A, k, param, function (err, result) {
        *    if (err) { console.log(err); }
        *    // successful calculation
        *    var U = result.U;
        *    var V = result.V;
        *    var s = result.s;
        * });
        * @example &lt;caption>Synchronous function&lt;/caption>
        * // import the modules
        * var la = require('qminer').la;
        * // create a random matrix
        * var A = new la.Matrix({ rows: 10, cols: 5, random: true });
        * // set the parameters for the calculation
        * var k = 2; // number of singular vectors
        * var param = { iter: 1000, tol: 1e-4 };
        * // calculate the svd
        * var result = la.svd(A, k, param);
        * // successful calculation
        * var U = result.U;
        * var V = result.V;
        * var s = result.s;
        */
     exports.prototype.svd = function (mat, k, json) { return { U: Object.create(require('qminer').la.Matrix.prototype), V: Object.create(require('qminer').la.Matrix.prototype), s: Object.create(require('qminer').la.Vector.prototype) } }
    /**
        * Computes the QR decomposition.
        * @param {module:la.Matrix} mat - The matrix.
        * @param {number} [tol = 1e-6] - The tolerance number.
        * @returns {Object} A JSON object `qrRes` which contains the decomposition matrices:
        * &lt;br>`qrRes.Q` - The orthogonal matrix Q of the QR decomposition. Type {@link module:la.Matrix}.
        * &lt;br>`qrRes.R` - The upper triangular matrix R of the QR decomposition. Type {@link module:la.Matrix}.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a random matrix
        * var mat = new la.Matrix({ rows: 10, cols: 5, random: true });
        * // calculate the QR decomposition of mat
        * var qrRes = la.qr(mat);
        */
     exports.prototype.qr = function (mat, tol) { return { Q: Object.create(require('qminer').la.Matrix.prototype), R: Object.create(require('qminer').la.Matrix.prototype) } }

    /**
     * Copyright (c) 2015, Jozef Stefan Institute, Quintelligence d.o.o. and contributors
     * All rights reserved.
     *
     * This source code is licensed under the FreeBSD license found in the
     * LICENSE file in the root directory of this source tree.
     */
    /**
    * Matrix constructor parameter object.
    * @typedef {Object} matrixArg
    * @property {number} rows - Number of rows.
    * @property {number} cols - Number of columns.
    * @property {boolean} [random=false] - Generate a random matrix with entries sampled from a uniform [0,1] distribution. If set to false, a zero matrix is created.
    */
    /**
    * Matrix class.
    * @classdesc Represents a dense matrix (2d array), wraps a C++ object implemented in glib/base/ds.h.
    * @class
    * @param {(module:la~matrixArg | Array&lt;Array&lt;number>> | module:la.Matrix)} [arg] - Constructor arguments. There are three ways of constructing:
    * &lt;br>1. Using the parameter object {@link module:la~matrixArg},
    * &lt;br>2. using a nested array of matrix elements (row major). Example: [[1,2],[3,4]] has two rows, the first row is [1,2],
    * &lt;br>3. using a dense matrix (copy constructor).
    * @example
    * // import la module
    * var la = require('qminer').la;
    * // create new matrix with matrixArg
    * var mat = new la.Matrix({"rows": 3, "cols": 2, "random": true}); // creates a 3 x 2 matrix with random values
    * // create a new matrix with nested arrays
    * var mat2 = new la.Matrix([[1, 7, 4], [-10, 0, 3]]); // creates a 2 x 3 matrix with the designated values
    */
     exports.Matrix = function(arg) { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Returns an element of matrix.
        * @param {number} rowIdx - Row index (zero based).
        * @param {number} colIdx - Column index (zero based).
        * @returns {number} The matrix element.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new matrix
        * var mat = new la.Matrix([[2, 3], [-2, -2], [-3, 1]]);
        * // get the value at the index (2, 1)
        * var value = mat.at(2, 1); // returns the value 1
        */
     exports.Matrix.prototype.at = function(rowIdx, colIdx) { return 0.0; }
    /**
        * Sets an element or a block of matrix.
        * @param {number} rowIdx - Row index (zero based).
        * @param {number} colIdx - Column index (zero based).
        * @param {(number | module:la.Matrix)} arg - A number or a matrix. If arg is of type {@link module:la.Matrix}, it gets copied, where the argument's upper left corner, &lt;code>arg.at(0,0)&lt;/code>, gets copied to position (&lt;code>rowIdx&lt;/code>, &lt;code>colIdx&lt;/code>).
        * @returns {module:la.Matrix} Self. The (&lt;code>rowIdx&lt;/code>, &lt;code>colIdx&lt;/code>) value/block is changed.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new matrix
        * var mat = new la.Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
        * var arg = new la.Matrix([[10, 11], [12, 13]]);
        * mat.put(0, 1, arg);
        * // updates the matrix to
        * // 1  10  11
        * // 4  12  13
        * // 7   8   9
        */
     exports.Matrix.prototype.put = function(rowIdx, colIdx, arg) { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Right-hand side multiplication of matrix with parameter.
        * @param {(number | module:la.Vector | module:la.SparseVector | module:la.Matrix | module:la.SparseMatrix)} arg - Multiplication input. Supports scalar, vector and matrix input.
        * @returns {(module:la.Matrix | module:la.Vector)}
        * &lt;br>1. {@link module:la.Matrix}, if &lt;code>arg&lt;/code> is a number, {@link module:la.Matrix} or {@link module:la.SparseMatrix}.
        * &lt;br>2. {@link module:la.Vector}, if &lt;code>arg&lt;/code> is a {@link module:la.Vector} or {@link module:la.SparseVector}.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new matrix
        * var mat = new la.Matrix([[1, 2], [-1, 5]]);
        * // create a new vector
        * var vec = new la.Vector([1, -1]);
        * //multiply mat and vec
        * var vec2 = mat.multiply(vec); // returns vector [-1, -6]
        */
     exports.Matrix.prototype.multiply = function(arg) { return (arg instanceof require('qminer').la.Vector | arg instanceof require('qminer').la.SparseVector) ? Object.create(require('qminer').la.Vector.prototype) : Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Matrix transpose and right-hand side multiplication of matrix with parameter.
        * @param {(number | module:la.Vector | module:la.SparseVector | module:la.Matrix | module:la.SparseMatrix)} arg - Multiplication input. Supports scalar, vector and matrix input.
        * @returns {(module:la.Matrix | module:la.Vector)}
        * &lt;br>1. {@link module:la.Matrix}, if &lt;code>arg&lt;/code> is a number, {@link module:la.Matrix} or a {@link module:la.SparseMatrix}.
        * &lt;br>2. {@link module:la.Vector}, if &lt;code>arg&lt;/code> is a {@link module:la.Vector} or a {@link module:la.SparseVector}.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new matrix
        * var mat = new la.Matrix([[1, 2], [-1, 5]]);
        * // create a new vector
        * var vec = new la.Vector([1, -1]);
        * //multiply mat and vec
        * var vec2 = mat.multiplyT(vec); // returns vector [2, -3]
        */
     exports.Matrix.prototype.multiplyT = function(arg) { return (arg instanceof require('qminer').la.Vector | arg instanceof require('qminer').la.SparseVector) ? Object.create(require('qminer').la.Vector.prototype) : Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Adds two matrices.
        * @param {module:la.Matrix} mat - The second matrix.
        * @returns {module:la.Matrix} The sum of the matrices.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create two matrices
        * var mat = new la.Matrix([[1, 2], [-1, 5]]);
        * var mat2 = new la.Matrix([[1, -1], [3, 2]]);
        * // add the matrices
        * // the return matrix is
        * // 2   1
        * // 2   7
        * var sum = mat.plus(mat2);
        */
     exports.Matrix.prototype.plus = function(mat2) { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Substracts two matrices.
        * @param {module:la.Matrix} mat - The second matrix.
        * @returns {module:la.Matrix} The difference of the matrices.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create two matrices
        * var mat = new la.Matrix([[1, 2], [-1, 5]]);
        * var mat2 = new la.Matrix([[1, -1], [3, 2]]);
        * // substract the matrices
        * // the return matrix is
        * //  0   3
        * // -4   3
        * var diff = mat.minus(mat2);
        */
     exports.Matrix.prototype.minus = function(mat2) { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Transposes the matrix.
        * @returns {module:la.Matrix} Transposed matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a matrix
        * var mat = new la.Matrix([[2, -5], [3, 1]]);
        * // transpose the matrix
        * // the return matrix is
        * //  2   3
        * // -5   1
        * var trans = mat.transpose();
        */
     exports.Matrix.prototype.transpose = function() { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Solves the linear system.
        * @param {module:la.Vector} vec - The right-hand side of the equation.
        * @returns {module:la.Vector} The solution of the linear system.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new matrix
        * var M = new la.Matrix([[1, 2], [-1, -5]]);
        * // create a new vector
        * var b = new la.Vector([-1, -6]);
        * // solve the linear system M*x = b
        * var x = M.solve(b); // returns vector [1, -1]
        */
     exports.Matrix.prototype.solve = function (vec) { return Object.create(require('qminer').la.Vector.prototype); }
    /**
        * Calculates the matrix row norms.
        * @returns {module:la.Vector} Vector, where the value at i-th index is the norm of the i-th row of matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new matrix
        * var mat = new la.Matrix([[3, 4], [4, 15/2]]);
        * // get the row norms of the matrix
        * var rowNorms = mat.rowNorms(); // returns the vector [5, 17/2]
        */
     exports.Matrix.prototype.rowNorms = function () { return Object.create(require('qminer').la.Vector.prototype); }
    /**
        * Calculates the matrix column norms.
        * @returns {module:la.Vector} Vector, where the value at i-th index is the norm of the i-th column of matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new matrix
        * var mat = new la.Matrix([[3, 4], [4, 15/2]]);
        * // get the row norms of the matrix
        * var rowNorms = mat.colNorms(); // returns the vector [5, 17/2]
        */
     exports.Matrix.prototype.colNorms = function () { return Object.create(require('qminer').la.Vector.prototype); }
    /**
        * Normalizes each column of matrix.
        * @returns {module:la.Matrix} Self. The columns of matrix are normalized.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new matrix
        * var mat = new la.Matrix([[3, 4], [4, 15/2]]);
        * // normalize the columns of the matrix
        * // the matrix is going to be of the form:
        * // 3/5     8/17
        * // 4/5    15/17
        * mat.normalizeCols();
        */
     exports.Matrix.prototype.normalizeCols = function () { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Returns the matrix as string.
        * @returns {string} Dense matrix as string.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new matrix
        * var mat = new la.Matrix([[1, 2], [3, 5]]);
        * // get matrix as string
        * var text = mat.toString(); // returns `1 2 \n3 5 \n\n`
        */
     exports.Matrix.prototype.toString = function () { return ""; }
    /**
        * Transforms the matrix from dense to sparse format.
        * @returns {module:la.SparseMatrix} Sparse column matrix representation of dense matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create the matrix
        * var mat = new la.Matrix([[1, 2], [0, 3], [-4, 0]]);
        * // transform the matrix into the sparse form
        * var spMat = mat.sparse();
        */
     exports.Matrix.prototype.sparse = function () { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Returns the frobenious norm of matrix.
        * @returns {number} Frobenious norm of matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create the matrix
        * var mat = new la.Matrix([[1, 2], [3, 4]]);
        * // get the frobenious norm of the matrix
        * var frob = mat.frob(); // returns the value Math.sqrt(30)
        */
     exports.Matrix.prototype.frob = function () { return 0.0; }
    /**
        * Gives the number of rows of matrix. Type `number`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create the matrix
        * var mat = new la.Matrix([[1, 2], [3, 1], [-4, 5]]);
        * // get the number of rows
        * var rowN = mat.rows; // returns 3
        */
     exports.Matrix.prototype.rows = 0;
    /**
        * Gives the number of columns of matrix. Type `number`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create the matrix
        * var mat = new la.Matrix([[1, 2], [3, 1], [-4, 5]]);
        * // get the number of cols
        * var colsN = mat.cols; // returns 2
        */
     exports.Matrix.prototype.cols = 0;
    /**
        * Gives the index of the maximum element in the given row.
        * @param {number} rowIdx - Row index (zero based).
        * @returns {number} Column index (zero based) of the maximum value in the &lt;code>rowIdx&lt;/code>-th row of matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create the matrix
        * var mat = new la.Matrix([[1, 2], [3, 1], [-4, 5]]);
        * // get the column id of the maximum value of the second row
        * var maxRow = mat.rowMaxIdx(1); // returns the value 0
        */
     exports.Matrix.prototype.rowMaxIdx = function (rowIdx) { return 0; }
    /**
        * Gives the index of the maximum element in the given column.
        * @param {number} colIdx - Column index (zero based).
        * @returns {number} Row index (zero based) of the maximum value in &lt;code>colIdx&lt;/code>-th column of matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create the matrix
        * var mat = new la.Matrix([[1, 2], [3, 1], [-4, 5]]);
        * // get the row id of the maximum value of the second column
        * var maxRow = mat.colMaxIdx(1); // returns the value 2
        */
     exports.Matrix.prototype.colMaxIdx = function (colIdx) { return 0; }
    /**
        * Returns the corresponding column of matrix as vector.
        * @param {number} colIdx - Column index (zero based).
        * @returns {module:la.Vector} The &lt;code>colIdx&lt;/code>-th column of matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create the matrix
        * var mat = new la.Matrix([[1, 2], [3, 1], [-4, 5]]);
        * // get the second column of the matrix
        * var col = mat.getCol(1);
        */
     exports.Matrix.prototype.getCol = function (colIdx) { return Object.create(require('qminer').la.Vector.prototype); }
    /**
        * Sets the column of the matrix.
        * @param {number} colIdx - Column index (zero based).
        * @param {module:la.Vector} vec - The new column of matrix.
        * @returns {module:la.Matrix} Self. The &lt;code>colIdx&lt;/code>-th column is changed.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a matrix
        * var mat = new la.Matrix([[1, -3, 2], [9, 2, -4],  [-2, 3, 3]]);
        * // create a vector
        * var vec = new la.Vector([-3, 2, 2]);
        * // set the first column of the matrix with the vector
        * // the changed matrix is now
        * // -3   -3    2
        * //  2    2   -4
        * //  2    3    3
        * mat.setCol(0, vec);
        */
     exports.Matrix.prototype.setCol = function (colIdx, vec) { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Gets the submatrix from the column ids.
        * @param {module:la.IntVector} intVec - The vector containing the column ids.
        * @returns {module:la.Matrix} The submatrix containing the the columns of the original matrix.
        * @example
        * //import la module
        * var la = require('qminer').la;
        * // create a random matrix
        * var mat = new la.Matrix({ rows: 10, cols: 10, random: true });
        * // get the submatrix containing the 1, 2 and 4 column
        * var submat = mat.getColSubmatrix(new la.IntVector([0, 1, 3]));
        */
     exports.Matrix.prototype.getColSubmatrix = function (intVec) { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Gets the submatrix from the column ids.
        * @param {number} minRow - The minimum row index.
        * @param {number} maxRow - The maximum row index.
        * @param {number} minCol - The minimum column index.
        * @param {number} maxCol - The maximum column index.
        * @returns {module:la.Matrix} The submatrix of the original matrix.
        * @example
        * //import la module
        * var la = require('qminer').la;
        * // create a random matrix
        * var mat = new la.Matrix({ rows: 10, cols: 10, random: true });
        * // get the submatrix containing from the position (1, 2) to (7, 4)
        * var submat = mat.getSubmatrix(1, 7, 2, 4);
        */
     exports.Matrix.prototype.getSubmatrix = function (minRow, maxRow, minCol, maxCol) { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Returns the corresponding row of matrix as vector.
        * @param {number} rowIdx - Row index (zero based).
        * @returns {module:la.Vector} The &lt;code>rowIdx&lt;/code>-th row of matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create the matrix
        * var mat = new la.Matrix([[1, 2], [3, 1], [-4, 5]]);
        * // get the first row of the matrix
        * var row = mat.getRow(1);
        */
     exports.Matrix.prototype.getRow = function (rowIdx) { return Object.create(require('qminer').la.Vector.prototype); }
    /**
        * Sets the row of matrix.
        * @param {number} rowIdx - Row index (zero based).
        * @param {module:la.Vector} vec - The new row of matrix.
        * @returns {module:la.Matrix} Self. The &lt;code>rowIdx&lt;/code>-th row is changed.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a matrix
        * var mat = new la.Matrix([[1, -3, 2], [9, 2, -4],  [-2, 3, 3]]);
        * // create a vector
        * var vec = new la.Vector([-3, 2, 2]);
        * // set the first row of the matrix with the vector
        * // the changed matrix is now
        * // -3    2    2
        * //  9    2   -4
        * // -2    3    3
        * mat.setRow(0, vec);
        */
     exports.Matrix.prototype.setRow = function (rowIdx, vec) { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Returns the diagonal elements of matrix.
        * @returns {module:la.Vector} Vector containing the diagonal elements.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new matrix
        * var mat = new la.Matrix([[1, -1, 0], [15, 8, 3], [0, 1, 0]]);
        * // call diag function
        * var vec = mat.diag(); // returns a vector [1, 8, 0]
        */
     exports.Matrix.prototype.diag = function () { return Object.create(require('qminer').la.Vector.prototype); }
    /**
        * Saves the matrix as output stream.
        * @param {module:fs.FOut} fout - Output stream.
        * @returns {module:fs.FOut} The output stream &lt;code>fout&lt;/code>.
        * @example
        * // import the modules
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create new matrix
        * var mat = new la.Matrix([[1, 2], [3, 4]]);
        * // open write stream
        * var fout = fs.openWrite('mat.dat');
        * // save matrix and close write stream
        * mat.save(fout).close();
        */
     exports.Matrix.prototype.save = function (fout) { return Object.create(require('qminer').fs.FOut.prototype); }
    /**
        * Loads the matrix from input stream.
        * @param {module:fs.FIn} fin - Input stream.
        * @returns {module:la.Matrix} Self. It is made out of the input stream &lt;code>fin&lt;/code>.
        * @example
        * // import the modules
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create an empty matrix
        * var mat = new la.Matrix();
        * // open a read stream ('mat.dat' is pre-saved)
        * var fin = fs.openRead('mat.dat');
        * // load the matrix
        * mat.load(fin);
        */
     exports.Matrix.prototype.load = function (FIn) { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
    * Sparse Vector.
    * @classdesc Sparse vector is an array of (int,double) pairs that represent column indices and values.
    * @class
    * @param {(Array&lt;Array&lt;number>> | module:la.SparseVector)} [arg] - Constructor arguments. There are two ways of constructing:
    * &lt;br>1. Using a nested array of vector elements. Example: `[[0, 2],[2, 3]]` has two nonzero values, first value is 2 at position 0, second value is 3 at position 2,
    * &lt;br>2. using a sparse vector (copy constructor).
    * @param {number} [dim] - Maximum length of sparse vector. &lt;i>It is only in combinantion with nested array of vector elements.&lt;/i>
    * @example
    * // import la module
    * var la = require('qminer').la;
    * // create new sparse vector with arrays
    * var spVec = new la.SparseVector([[0, 1], [2, 3], [3, 6]]); // sparse vector [1, 0, 3, 6]
    * // create new sparse vector with dim
    * var spVec2 = new la.SparseVector([[0, 1], [2, 3], [3, 6]], 5); // largest index (zero based) is 4
    */
     exports.SparseVector = function(arg, dim) { return Object.create(require('qminer').la.SparseVector.prototype); }
    /**
        * Returns an element of the sparse vector.
        * @param {number} idx - Index (zero based).
        * @returns {number} Sparse vector element.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a sparse vector
        * var vec = new la.SparseVector([[0, 1], [3, 2], [4, -5]]);
        * // get the value at the position 3
        * vec.at(3); // returns the value 2
        */
     exports.SparseVector.prototype.at = function (idx) { return 0.0; }
    /**
        * Puts a new element in sparse vector.
        * @param {number} idx - Index (zero based).
        * @param {number} num - Input value.
        * @returns {module:la.SparseVector} Self. It puts/changes the values with the index `idx` to the value `num`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse vector
        * var vec = new la.SparseVector([[0, 1], [3, 2], [4, -5]]);
        * // set the new values at position 2
        * vec.put(2, -4);
        */
     exports.SparseVector.prototype.put = function (idx, num) { return Object.create(require('qminer').la.SparseVector.prototype); }
    /**
        * Returns the sum of all values in sparse vector.
        * @returns {number} The sum of all values in sparse vector.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse vector
        * var vec = new la.SparseVector([[0, 1], [3, 2], [4, -5]]);
        * // get the sum of the values in the vector
        * vec.sum(); // returns -2
        */
     exports.SparseVector.prototype.sum = function () { return 0.0; }
    /**
        * Returns the inner product of the parameter and the sparse vector.
        * @param {(module:la.Vector | module:la.SparseVector)} arg - The inner product input.
        * @returns {number} The inner product of the two vectors.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create two vectors, one sparse and one dense
        * var sparse = new la.SparseVector([[0, 1], [3, 2], [4, -5]]);
        * var dense = new la.Vector([3, -4, 2, 0.5, -1]);
        * // get the inner product of the vectors
        * sparse.inner(dense); // returns the value 9
        */
     exports.SparseVector.prototype.inner = function (arg) { return 0.0; }
    /**
        * Multiplies the sparse vector with a scalar.
        * @param {number} num - The scalar.
        * @returns {module:la.SparseVector} The product of `num` and sparse vector.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse vector
        * var spVec = new la.SparseVector([[0, 1], [2, 3], [3, 6]]);
        * // multiply sparse vector with scalar 3.14
        * var spVec2 = spVec.multiply(3.14); // returns sparse vector [3.14, 0, 9.42, 18.84]
        */
     exports.SparseVector.prototype.multiply = function (num) { return Object.create(require('qminer').la.SparseVector.prototype); }
    /**
        * Normalizes the sparse vector.
        * @returns {module:la.SparseVector} Self. The vector is normalized.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse vector
        * var spVec = new la.SparseVector([[0, 1], [2, 3], [3, 6]]);
        * // normalize the sparse vector
        * spVec.normalize();
        */
     exports.SparseVector.prototype.normalize = function () { return Object.create(require('qminer').la.SparseVector.prototype); }
    /**
        * Returns the number of non-zero values. Type `number`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse vector
        * var vec = new la.SparseVector([[0, 2], [3, 1], [7, 5], [11, 4]]);
        * // check the number of nonzero values in sparse vector
        * // returns 4
        * var nonz = vec.nnz;
        */
     exports.SparseVector.prototype.nnz = 0;
    /**
        * Returns the dimension of sparse vector. Type `number`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse vector and designate the dimension of the vector
        * var vec = new la.SparseVector([[0, 2], [3, 1], [7, 5], [11, 4]], 15);
        * // get the dimension of the sparse vector
        * // returns 15
        * var dim = vec.dim;
        */
     exports.SparseVector.prototype.dim = 0;
    /**
        * Returns the norm of sparse vector.
        * @returns {number} Norm of sparse vector.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse vector
        * var vec = new la.SparseVector([[0, 2], [3, 1], [7, 5], [11, 4]]);
        * // get the norm of the vector
        * var norm = vec.norm();
        */
     exports.SparseVector.prototype.norm = function () { return 0.0; }
    /**
        * Returns the dense vector representation of the sparse vector.
        * @returns {module:la.Vector} The dense vector representation.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse vector
        * var vec = new la.SparseVector([[0, 2], [3, 1], [7, 5], [11, 4]]);
        * // create a dense representation of the vector
        * var dense = vec.full();
        */
     exports.SparseVector.prototype.full = function () { return Object.create(require('qminer').la.Vector.prototype); }
    /**
        * Returns a dense vector of values of non-zero elements of sparse vector.
        * @returns {module:la.Vector} A dense vector of values.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse vector
        * var vec = new la.SparseVector([[0, 2], [3, 1], [7, 5], [11, 4]]);
        * // get the non-zero values of the sparse vector
        * var valVec = vec.valVec();
        */
     exports.SparseVector.prototype.valVec = function () { return Object.create(require('qminer').la.Vector.prototype); }
    /**
        * Returns a dense vector of indices (zero based) of non-zero elements of sparse vector.
        * @returns {module:la.Vector} A dense vector of indeces.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sprase vector
        * var vec = new la.SparseVector([[0, 2], [3, 1], [7, 5], [11, 4]]);
        * // get the non-zero indeces of the sparse vector
        * var idxVec = vec.idxVec();
        */
     exports.SparseVector.prototype.idxVec = function () { return Object.create(require('qminer').la.Vector.prototype); }
    /**
        * Returns the string representation.
        * @returns {string} The string representation of the sparse vector.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse vector
        * var spVec = new la.SparseVector([[0, 1], [2, 3]]);
        * // get the string representation of the vector
        * spVec.toString(); // returns the string '[(0, 1), (2, 3)]'
        */
     exports.SparseVector.prototype.toString = function () { return ""; }
    /**
    * Sparse Matrix
    * @classdesc Sparse Matrix is represented as a dense vector of sparse vectors which correspond to matrix columns.
    * @class
    * @param {(Array&lt;Array&lt;Array&lt;number>>> | module:la.SparseMatrix)} [arg] - Constructor arguments. There are two ways of constructing:
    * &lt;br>1. using a nested array of sparse vectors (columns). A sparse vector is a nested array of pairs, first value is index, second is value. Example: [[[0, 2]], [[0, 1], [2, 3]]] has 2 columns.
    * The second non-zero element in second column has a value 3 at index 2,
    * &lt;br>2. using a sparse matrix (copy constructor).
    * @param {number} [rows] - Maximal number of rows in sparse vector. &lt;i>It is only in combinantion with nested array of vector elements.&lt;/i>
    * @example
    * // import la module
    * var la = require('qminer').la;
    * // create a new sparse matrix with array
    * var mat = new la.SparseMatrix([[[0, 2]], [[0, 1], [2, 3]]]);
    * // create a new sparse matrix with specified max rows
    * var mat2 = new la.SparseMatrix([[[0, 2]], [[0, 1], [2, 3]]], 3);
    */
     exports.SparseMatrix = function(arg) { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Returns an element of the sparse matrix at the given location.
        * @param {number} rowIdx - Row index (zero based).
        * @param {number} colIdx - Column index (zero based).
        * @returns {number} Matrix value.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a sparse matrix
        * var mat = new la.SparseMatrix([[[0, 2]], [[0, 1], [2, 3]]]);
        * // get the value at the position (1, 1)
        * mat.at(1, 1); // returns 3
        */
     exports.SparseMatrix.prototype.at = function (rowIdx, colIdx) { return 0.0; }
    /**
        * Puts an element in sparse matrix.
        * @param {number} rowIdx - Row index (zero based).
        * @param {number} colIdx - Column index (zero based).
        * @param {number} num - Element value.
        * @returns {module:la.SparseMatrix} Self. The value at position (`rowIdx`, `colIdx`) is changed.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 3], [1, 2]], [[1, -2], [3, 4]], [[10, 8]]]);
        * // set the value at position (2, 2) to -4
        * mat.put(2, 2, -4);
        */
     exports.SparseMatrix.prototype.put = function (rowIdx, colIdx, num) { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Returns the column of the sparse matrix.
        * @param {number} colIdx - The column index (zero based).
        * @returns {module:la.SparseVector} Sparse vector corresponding to the `colIdx`-th column of sparse matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a sparse matrix
        * var mat = new la.SparseMatrix([[[0, 3], [1, 2]], [[1, -2], [3, 4]], [[10, 8]]]);
        * // get the first column as a vector
        * var first = mat.getCol(0); // returns the first column of the sparse matrix
        */
     exports.SparseMatrix.prototype.getCol = function (colIdx) { return Object.create(require('qminer').la.SparseVector.prototype); }
    /**
        * Sets a column in sparse matrix.
        * @param {number} colIdx - Column index (zero based).
        * @param {module:la.SparseVector} spVec - The new column sparse vector.
        * @returns {module:la.SparseMatrix} Self. The `colIdx`-th column has been replaced with `spVec`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 3], [1, 2]], [[1, -2], [3, 4]], [[10, 8]]]);
        * // create a new sparse vector to replace the third column
        * var vec = new la.SparseVector([[0, 3], [2, -5]]);
        * // set the third column of mat to vec
        * mat.setCol(2, vec); // returns mat with the third column changed
        */
     exports.SparseMatrix.prototype.setCol = function (colIdx, spVec) { return Object.create(require('qminer').la.SparseVector.prototype); }
    /**
        * Attaches a column to the sparse matrix.
        * @param {module:la.SparseVector} spVec - Attached column as sparse vector.
        * @returns {module:la.SparseMatrix} Self. The last column is now the added `spVec` and the number of columns is now bigger by one.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse vector
        * var mat = new la.SparseMatrix([[[0, 2], [3, 5]], [[1, -3]]]);
        * // create a new vector
        * var vec = new la.SparseVector([[0, 2], [2, -3]]);
        * // push the newly created vector to the matrix
        * // the new matrix is going to be (in sparse form)
        * // 2    0    2
        * // 0   -3    0
        * // 0    0   -3
        * // 5    0    0
        * mat.push(vec);
        */
     exports.SparseMatrix.prototype.push = function (spVec) { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Multiplies argument with sparse maatrix.
        * @param {(number | module:la.Vector | module:la.SparseVector | module:la.Matrix | module:la.SparseMatrix)} arg - Multiplication input.
        * @returns {(module:la.Vector | module:la.Matrix)}
        * &lt;br>1. {@link module:la.Matrix}, if `arg` is number, {@link module:la.Matrix} or {@link module:la.SparseMatrix}.
        * &lt;br>2. {@link module:la.Vector}, if `arg` is {@link module:la.Vector} or {@link module:la.SparseVector}.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 2], [3, 5]], [[1, -3]]]);
        * // create a vector
        * var vec = new la.Vector([3, -2]);
        * // multiply the matrix and vector
        * var vec2 = mat.multiply(vec);
        */
     exports.SparseMatrix.prototype.multiply = function (arg) { return (arg instanceof require('qminer').la.Vector | arg instanceof require('qminer').la.SparseVector) ? Object.create(require('qminer').la.Vector.prototype) : Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Sparse matrix transpose and multiplies with argument.
        * @param {(number | module:la.Vector | module:la.SparseVector | module:la.Matrix | module:la.SparseMatrix)} arg - Multiplication input.
        * @returns {(module:la.Vector | module:la.Matrix)}
        * &lt;br>1. {@link module:la.Matrix}, if `arg` is number, {@link module:la.Matrix} or {@link module:la.SparseMatrix}.
        * &lt;br>2. {@link module:la.Vector}, if `arg` is {@link module:la.Vector} or {@link module:la.SparseVector}.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 2], [3, 5]], [[1, -3]]]);
        * // create a dense matrix
        * var mat2 = new la.Matrix([[0, 1], [2, 3], [4, 5], [-1, 3]]);
        * // transpose mat and multiply it with mat2
        * var mat3 = mat.multiplyT(mat2);
        */
     exports.SparseMatrix.prototype.multiplyT = function (arg) { return (arg instanceof require('qminer').la.Vector | arg instanceof require('qminer').la.SparseVector) ? Object.create(require('qminer').la.Vector.prototype) : Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Addition of two matrices.
        * @param {module:la.SparseMatrix} mat - The second sparse matrix.
        * @returns {module:la.SparseMatrix} Sum of the two sparse matrices.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create two sparse matrices
        * var mat = new la.SparseMatrix([[[0, 1], [3, 2]], [[1, -3]]]);
        * var mat2 = new la.SparseMatrix([[[0, 3]],[[2, 1]]]);
        * // get the sum of the two matrices
        * // returns the sum ( insparse form)
        * // 4    0
        * // 0   -3
        * // 0    1
        * // 2    0
        * var sum = mat.plus(mat2);
        */
     exports.SparseMatrix.prototype.plus = function (spMat) { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Substraction of two matrices.
        * @param {module:la.SparseMatrix} mat - The second sparse matrix.
        * @returns {module:la.SparseMatrix} The difference of the two sparse matrices.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create two sparse matrices
        * var mat = new la.SparseMatrix([[[0, 1], [3, 2]], [[1, -3]]]);
        * var mat2 = new la.SparseMatrix([[[0, 3]],[[2, 1]]]);
        * // get the sum of the two matrices
        * // returns the sum ( insparse form)
        * // -2    0
        * //  0   -3
        * //  0   -1
        * //  2    0
        * var diff = mat.minus(mat2);
        */
     exports.SparseMatrix.prototype.minus = function (spMat) { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Returns the transposed sparse matrix.
        * @returns {module:la.SparseMatrix} Transposed sparse matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 2], [2, -3]], [[1, 1], [3, -2]]]);
        * // transpose the sparse matrix
        * // returns the transposed matrix (in sparse form)
        * // 2    0   -3    0
        * // 0    1    0   -2
        * mat.transpose();
        */
     exports.SparseMatrix.prototype.transpose = function () { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Returns a submatrix containing only selected columns.
        * Columns are identified by a vector of ids.
        * @param {module:la.IntVector} columnIdVec - Integer vector containing selected column ids.
        * @returns {module:la.SparseMatrix} The submatrix containing the the columns of the original matrix.
        * @example
        * //import la module
        * var la = require('qminer').la;
        * // create a new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 2], [2, -3]], [[1, 1], [3, -2]]]);
        * // get the submatrix containing the 1, 2 and 4 column
        * var submat = mat.getColSubmatrix(new la.IntVector([1]));
        */
     exports.SparseMatrix.prototype.getColSubmatrix = function (columnIdVec) { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Clear content of the matrix and sets its row dimension to -1.
        * @returns {module:la.SparseMatrix} Self. All the content has been cleared.
        * @example
        * //import la module
        * var la = require('qminer').la;
        * // create a new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 2], [2, -3]], [[1, 1], [3, -2]]]);
        * // clear the matrix
        * mat.clear();
        */
     exports.SparseMatrix.prototype.clear = function () { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Returns the vector of column norms of sparse matrix.
        * @returns {module:la.Vector} Vector of column norms. Ihe i-th value of the return vector is the norm of i-th column of sparse matrix.
        * @example
        * //import la module
        * var la = require('qminer').la;
        * // create a new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 2], [2, -3]], [[1, 1], [3, -2]]]);
        * // get the column norms
        * var norms = mat.colNorms();
        */
     exports.SparseMatrix.prototype.colNorms = function () { return Object.create(require('qminer').la.Vector.prototype); }
    /**
        * Normalizes columns of sparse matrix.
        * @returns {module:la.SparseMatrix} Self. The columns of the sparse matrix are normalized.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 2]], [[0, 1], [2, 3]]]);
        * // normalize matrix columns
        * // The new matrix elements are:
        * // 1  0.316227
        * // 0  0
        * // 0  0.948683
        * mat.normalizeCols();
        */
     exports.SparseMatrix.prototype.normalizeCols = function () { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Returns the dense representation of sparse matrix.
        * @returns {module:la.Matrix} Dense representation of sparse matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 2]], [[0, 1], [2, 3]]]);
        * // create a dense representation of sparse matrix
        * // returns the dense matrix:
        * // 2  1
        * // 0  0
        * // 0  3
        * mat.full();
        */
     exports.SparseMatrix.prototype.full = function () { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Returns the frobenious norm of sparse matrix.
        * @returns {number} Frobenious norm of sparse matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 1], [1, 3]], [[0, 2], [1, 4]]]);
        * // get the frobenious norm of sparse matrix
        * var norm = mat.frob(); // returns sqrt(30)
        */
     exports.SparseMatrix.prototype.frob = function () { return 0.0; }
    /**
        * Gives the number of rows of sparse matrix. Type `number`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 2]], [[0, 1], [2, 3]]]);
        * // check the number of rows in sparse matrix
        * mat.rows;
        */
     exports.SparseMatrix.prototype.rows = 0;
    /**
        * Gives the number of columns of sparse matrix. Type `number`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 2]], [[0, 1], [2, 3]]]);
        * // check the number of columns in sparse matrix
        * mat.cols;
        */
     exports.SparseMatrix.prototype.cols = 0;
    /**
        * Prints sparse matrix on screen.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse matrix
        * var spMat = new la.SparseMatrix([[[0, 1]], [[0, 3], [1, 8]]]);
        * // print sparse matrix on screen
        * // each row represents a nonzero element, where first value is row index, second
        * // value is column index and third value is element value. For this matrix:
        * // 0  0  1.000000
        * // 0  1  3.000000
        * // 1  1  8.000000
        * spMat.print();
        */
     exports.SparseMatrix.prototype.print = function () {}
    /**
        * Saves the sparse matrix as output stream.
        * @param {module:fs.FOut} fout - Output stream.
        * @param {boolean} [saveMatlab=false] - If true, saves using matlab three column text format. Otherwise, saves using binary format.
        * @returns {module:fs.FOut} The output stream `fout`.
        * @example
        * // import the modules
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create a new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 1]], [[0, 3], [1, 12]]]);
        * // open write stream
        * var fout = fs.openWrite('mat.dat');
        * // save matrix and close write stream
        * mat.save(fout).close();
        */
     exports.SparseMatrix.prototype.save = function (fout, saveMatlab) { return Object.create(require('qminer').fs.FOut.prototype); }
    /**
        * Loads the sparse matrix from input stream.
        * @param {module:fs.FIn} fin - Input stream.
        * @returns {module:la.Matrix} Self. The content has been loaded using `fin`.
        * @example
        * // import the modules
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create an empty matrix
        * var mat = new la.SparseMatrix();
        * // open a read stream ('mat.dat' was previously created)
        * var fin = fs.openRead('mat.dat');
        * // load the matrix
        * mat.load(fin);
        */
     exports.SparseMatrix.prototype.load = function (FIn) { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Sets the row dimension.
        * @param {number} rowDim - Row dimension.
        * @example
        * // import the modules
        * var la = require('qminer').la;
        * // create an empty matrix
        * var mat = new la.SparseMatrix();
        * mat.setRowDim(2);
        * mat.rows // prints 2
        */
     exports.SparseMatrix.prototype.setRowDim = function (rowDim) { }

        /**
        * Calculates the frobenious norm squared of the matrix.
        * @returns {number} Frobenious norm squared.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a sparse matrix
        * var spMat = new la.SparseMatrix([[[0, 1], [1, 5]], [[0, 2], [2, -3]]]);
        * // get the forbenious norm squared of the sparse matrix
        * var frob = spMat.frob2();
        */
        exports.SparseMatrix.prototype.frob2 = function () {
            return Math.pow(this.frob(), 2);
        }

        /**
        * Returns a string displaying rows, columns and number of non-zero elements of sparse matrix.
        * @returns {string} String displaying row, columns and number of non-zero elements.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new sparse matrix
        * var mat = new la.SparseMatrix([[[0, 1]], [[0, 2], [1, 8]]]);
        * // create the string
        * var text = mat.toString(); // returns 'rows: -1, cols: 2, nnz: 3'
        */
        exports.SparseMatrix.prototype.toString = function () { return "rows: " + this.rows + ", cols:" + this.cols + ", nnz: " + this.nnz(); }

        /**
        * Returns the number of non-zero elements of sparse matrix.
        * @returns {number} Number of non-zero elements.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a sparse matrix
        * var spMat = new la.SparseMatrix([[[0, 1], [1, 5]], [[0, 2], [2, -3]]]);
        * // get the number of non-zero elements
        * // returns 4
        * var nnz = spMat.nnz();
        */
        exports.SparseMatrix.prototype.nnz = function () {
            var nnz = 0;
            //iterate over matrix and sum nnz of each column
            for (var colN = 0; colN &lt; this.cols; colN++) {
                nnz += this[colN].nnz;
            }
            return nnz;
        };

        /**
    	* Prints the sparse vector on-screen.
    	* @example
        * // import la module
        * var la = require('qminer').la;
    	* // create a new sparse vector
    	* var spVec = new la.SparseVector([[0, 1], [2, 3]]);
    	* // print sparse vector
    	* spVec.print(); // shows on-screen [(0, 1), (2, 3)]
    	*/
        exports.SparseVector.prototype.print = function () { console.log(this.toString()); }

        /**
    	* Prints the matrix on-screen.
    	* @example
        * // import la module
        * var la = require('qminer').la;
    	* // create a new matrix
    	* var mat = new la.Matrix([[1, 2], [3, 4]]);
    	* // print the matrix
        * // each row represents a row in the matrix. For this example:
        * // 1  2
        * // 3  4
    	* mat.print();
    	*/
        exports.Matrix.prototype.print = function () { console.log(this.toString()); }

    	/**
    	* Returns a copy of the matrix.
    	* @returns {module:la.Matrix} Matrix copy.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a random matrix
        * var mat = new la.Matrix({ rows: 5, cols: 4, random: true });
        * // create a copy of the matrix
        * var copy = mat.toMat();
    	*/
    	exports.Matrix.prototype.toMat = function () { return new exports.Matrix(this); }

    	/**
        * Prints the vector on-screen.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // print the vector
        * // For this example it prints:
        * // [1, 2, 3]
        * vec.print();
        */
    	exports.Vector.prototype.print = function () { console.log(this.toString()); }

        function vec2arr(vec) {
        	var len = vec.length;
            var arr = [];
            for (var elN = 0; elN &lt; len; elN++) {
                arr[elN] = vec[elN];
            }
            return arr;
        }

    	/**
        * Copies the vector into a JavaScript array of numbers.
        * @returns {Array.&lt;number>} A JavaScript array of numbers.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // create a JavaScript array out of vec
        * var arr = vec.toArray(); // returns an array [1, 2, 3]
        */
        exports.Vector.prototype.toArray = function () {
            return vec2arr(this);
    	}
    	/**
        * Copies the vector into a JavaScript array of numbers.
        * @returns {Array.&lt;number>} A JavaScript array of integers.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new integer vector
        * var vec = new la.IntVector([1, 2, 3]);
        * // create a JavaScript array out of vec
        * var arr = vec.toArray(); // returns an array [1, 2, 3]
        */
    	exports.IntVector.prototype.toArray = function () {
            return vec2arr(this);
    	}
    	/**
        * Copies the vector into a JavaScript array of strings.
        * @returns {Array.&lt;string>} A JavaScript array of strings.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(["one", "two", "three"]);
        * // create a JavaScript array out of vec
        * var arr = vec.toArray(); // returns an array ["one", "two", "three"]
        */
    	exports.StrVector.prototype.toArray = function () {
            return vec2arr(this);
    	}
    	/**
        * Copies the vector into a JavaScript array of booleans.
        * @returns {Array.&lt;boolean>} A JavaScript array of booleans.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, false, true]);
        * // create a JavaScript array out of vec
        * var arr = vec.toArray(); // returns an array [true, false, true]
        */
    	exports.BoolVector.prototype.toArray = function () {
            return vec2arr(this);
    	}

    	/**
        * Copies the matrix into a JavaScript array of arrays of numbers.
        * @returns {Array&lt;Array&lt;number>>} A JavaScript array of arrays of numbers.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new matrix
        * var mat = new la.Matrix([[1, 2], [3, 4]]);
        * // create a JavaScript array out of matrix
        * var arr = mat.toArray(); // returns an array [[1, 2], [3, 4]]
        */
        exports.Matrix.prototype.toArray = function () {
            var rows = this.rows;
    		var cols = this.cols;
            var arr = [];
            for (var i = 0; i &lt; rows; i++) {
    			var arr_row = [];
    			for (var j = 0; j &lt; cols; j++) {
    				arr_row.push(this.at(i, j));
    			}
                arr.push(arr_row);
            }
            return arr;
    	}

        /**
        * Copies the vector into a JavaScript array of numbers.
        * @param {module:la.Vector} vec - Copied vector.
        * @returns {Array&lt;number>} A JavaScript array of numbers.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // create a JavaScript array out of vec
        * var arr = la.copyVecToArray(vec); // returns an array [1, 2, 3]
        */
        exports.copyVecToArray = function (vec) { return vec.toArray(); };

        function isInt(value) {
            return !isNaN(value) &amp;&amp;
                   parseInt(Number(value)) == value &amp;&amp;
                   !isNaN(parseInt(value, 10));
        }

        ///////// RANDOM GENERATORS

        /**
        * Returns an object with random numbers.
        * @param {number} [arg1] - Represents dimension of vector or number of rows in matrix. Must be an integer.
        * @param {number} [arg2] - Represents number of columns in matrix. Must be an integer.
        * @returns {(number | module:la.Vector | module:la.Matrix)}
        * &lt;br>1. Number, if no parameters are given.
        * &lt;br>2. {@link module:la.Vector}, if parameter `arg1` is given.
        * &lt;br>3. {@link module:la.Matrix}, if parameters `arg1` and `arg2` are given.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // generate a random number
        * var number = la.randn();
        * // generate a random vector of length 7
        * var vector = la.randn(7);
        * // generate a random matrix with 7 rows and 10 columns
        * var mat = la.randn(7, 10);
        */
        exports.randn = function (arg1, arg2) {
            //arguments.length
            var len = arguments.length;
            if (len === 0) {
                var x1, x2, rad, y1;
                do {
                    x1 = 2 * Math.random() - 1;
                    x2 = 2 * Math.random() - 1;
                    rad = x1 * x1 + x2 * x2;
                } while (rad >= 1 || rad == 0);
                var c = Math.sqrt(-2 * Math.log(rad) / rad);
                return x1 * c;
            } else if (len === 1) {
                var dim = arguments[0];
                assert(isInt(dim));
                var vec = new exports.Vector({ "vals": dim });
                for (var elN = 0; elN &lt; dim; elN++) {
                    vec.put(elN, exports.randn());
                }
                return vec;
            } else if (len === 2) {
                var rows = arguments[0];
                var cols = arguments[1];
                assert(isInt(rows));
                assert(isInt(cols));
                var mat = new exports.Matrix({ "cols": cols, "rows": rows });
                for (var colN = 0; colN &lt; cols; colN++) {
                    for (var rowN = 0; rowN &lt; rows; rowN++) {
                        mat.put(rowN, colN, exports.randn());
                    }
                }
                return mat;
            }
        };

        /**
        * Returns a randomly selected integer(s) from an array.
        * @param {number} num - The upper bound of the array. Must be an integer.
        * @param {number} [len] - The number of selected integers. Must be an integer.
        * @returns {(number | la.IntVector)}
        * &lt;br>1. Randomly selected integer from the array `[0,...,num-1]`, if no parameters are given.
        * &lt;br>2. {@link module:la.IntVector}, if parameter `len` is given. The vector contains random integers from the array `[0,...,num-1]` (with repetition).
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // generate a random integer between 0 and 10
        * var number = la.randi(10);
        * // generate an integer vector containing 5 random integers between 0 and 10
        * var vec = la.randi(10, 5);
        */
        exports.randi = function () {
            var len = arguments.length;
            if (len === 1) {
                var n = arguments[0];
                assert(isInt(n), "one integer argument expected");
                return Math.floor((Math.random() * n));
            } else if (len == 2) {
                var n = arguments[0];
                var size = arguments[1];
                assert(isInt(n), "integer argument[0] expected");
                assert(isInt(size), "integer argument[1] expected");
                var result = new exports.IntVector({ "vals": size });
                for (var i = 0; i &lt; size; i++) {
                    result[i] = Math.floor((Math.random() * n));
                }
                return result;
            } else {
                throw new Error("one integer argument expected");
            }
        };

        /**
        * Returns a JavaScript array, which is a sample of integers from an array.
        * @param {number} n - The upper bound of the generated array `[0,...,n-1]`. Must be an integer.
        * @param {number} k - Length of the sample. Must be smaller or equal to `n`.
        * @returns {Array&lt;number>} The sample of `k` numbers from `[0,...,n-1]`, sampled without replacement.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create an array containing 5 integers between 0 and 15
        * var arr = la.randVariation(15, 5);
        */
        exports.randVariation = function (n, k) {
            var n = arguments[0];
            var k = arguments[1];
            assert(isInt(n));
            assert(isInt(k));
            var perm = exports.copyVecToArray(exports.randPerm(n));
            var idx = perm.slice(0, k);
            return idx;
        };

        /**
        * Returns a permutation of elements.
        * @param {number} k - Number of elements to permutate.
        * @returns {Array&lt;number>} A JavaScript array of integers. Represents a permutation of `k` elements.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create an array/permutation of 5 elements
        * var perm = la.randPerm(5);
        */
        exports.randPerm = function (k) {
            assert(isInt(k));
            // gaussian random vector
            var vec = exports.randn(k);
            var res = vec.sortPerm();
            return res.perm;
        };

        ///////// COMMON MATRICES

        /**
        * Returns an dense identity matrix.
        * @param {number} dim - The dimension of the identity matrix. Must be a positive integer.
        * @returns {module:la.Matrix} A `dim`-by-`dim` identity matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // generate a dense identity matrix of dimension 5
        * var id = la.eye(5);
        */
        exports.eye = function(dim) {
            var identity = new exports.Matrix({ "rows": dim, "cols": dim });
            for (var rowN = 0; rowN &lt; identity.rows; rowN++) {
                identity.put(rowN, rowN, 1.0);
            }
            return identity;
        };

        /**
        * Returns a sparse identity matrix
        * @param {number} dim - The dimension of the identity matrix. Must be a positive integer.
        * @returns {module:la.SparseMatrix} A dim-by-dim identity matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // generate a sparse identity matrix of dimension 5
        * var spId = la.speye(5);
        */
        exports.speye = function (dim) {
            var vec = exports.ones(dim);
            return vec.spDiag();
        };

        /**
        * Returns a sparse zero matrix.
        * @param {number} rows - Number of rows of the sparse matrix.
        * @param {number} [cols = rows] - Number of columns of the sparse matrix.
        * @returns {module:la.SparseMatrix} A `rows`-by-`cols` sparse zero matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a sparse zero matrix with 5 rows and columns
        * var spMat = la.sparse(5);
        */
        exports.sparse = function (rows, cols) {
            cols = typeof cols == 'undefined' ? rows : cols;
            var spmat = new exports.SparseMatrix({ "rows": rows, "cols": cols });
            return spmat;
        };

        /**
        * Returns a dense zero matrix.
        * @param {number} rows - Number of rows of the matrix.
        * @param {number} [cols = rows] - Number of columns of the matrix.
        * @returns {module:la.Matrix} A `rows`-by-`cols` dense zero matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a sparse zero matrix with 5 rows and 3 columns
        * var mat = la.zeros(5, 3);
        */
        exports.zeros = function (rows, cols) {
            cols = typeof cols == 'undefined' ? rows : cols;
            var mat = new exports.Matrix({ "rows": rows, "cols": cols });
            return mat;
        };

        /**
        * Returns a vector with all entries set to 1.0.
        * @param {number} dim - Dimension of the vector.
        * @returns {module:la.Vector} A `dim`-dimensional vector whose entries are set to 1.0.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a 3-dimensional vector with all entries set to 1.0
        * var vec = la.ones(3);
        */
        exports.ones = function(k) {
            var ones_k = new exports.Vector({ "vals": k });
            for (var i = 0; i &lt; k; i++) {
                ones_k.put(i, 1.0);
            }
            return ones_k;
        };

        /**
        * Constructs a matrix by concatenating a double-nested array of matrices.
        * @param {Array&lt;Array&lt;module:la.Matrix>> } nestedArrMat - An array of block rows, where each block row is an array of matrices.
        * For example: `[[m_11, m_12], [m_21, m_22]]` is used to construct a matrix where the (i,j)-th block submatrix is `m_ij`.
        * @returns {module:la.Matrix} Concatenated matrix.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create four matrices and concatenate (2 block columns, 2 block rows)
        * var la = require('qminer').la;
        * var A = new la.Matrix([[1,2], [3,4]]);
        * var B = new la.Matrix([[5,6], [7,8]]);
        * var C = new la.Matrix([[9,10], [11,12]]);
        * var D = new la.Matrix([[13,14], [15,16]]);
        * // create a nested matrix
        * // returns the matrix:
        * // 1  2  5  6
        * // 3  4  7  8
        * // 9  10 13 14
        * // 11 12 15 16
        * var mat = la.cat([[A,B], [C,D]]);
        */
        exports.cat = function (nestedArrMat) {
            var dimx = []; //cell row dimensions
            var dimy = []; //cell col dimensions
            var cdimx = []; //cumulative row dims
            var cdimy = []; //cumulative coldims
            var rows = nestedArrMat.length;
            var cols = nestedArrMat[0].length;
            for (var row = 0; row &lt; rows; row++) {
                for (var col = 0; col &lt; cols; col++) {
                    if (col > 0) {
                        assert(dimx[row] == nestedArrMat[row][col].rows, 'inconsistent row dimensions!');
                    } else {
                        dimx[row] = nestedArrMat[row][col].rows;
                    }
                    if (row > 0) {
                        assert(dimy[col] == nestedArrMat[row][col].cols, 'inconsistent column dimensions!');
                    } else {
                        dimy[col] = nestedArrMat[row][col].cols;
                    }
                }
            }
            cdimx[0] = 0;
            cdimy[0] = 0;
            for (var row = 1; row &lt; rows; row++) {
                cdimx[row] = cdimx[row - 1] + dimx[row - 1];
            }
            for (var col = 1; col &lt; cols; col++) {
                cdimy[col] = cdimy[col - 1] + dimy[col - 1];
            }

            var res = new exports.Matrix({ rows: (cdimx[rows - 1] + dimx[rows - 1]), cols: (cdimy[cols - 1] + dimy[cols - 1]) });
            // copy submatrices
            for (var row = 0; row &lt; rows; row++) {
                for (var col = 0; col &lt; cols; col++) {
                    res.put(cdimx[row], cdimy[col], nestedArrMat[row][col]);
                }
            }
            return res;
        }

        /**
        * Generates an integer vector given range.
        * @param {number} min - Start value. Should be an integer.
        * @param {number} max - End value. Should be an integer.
        * @returns {module:la.IntVector} Integer range vector.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a range vector containing 1, 2, 3
        * var vec = la.rangeVec(1, 3);
        */
        exports.rangeVec = function (min, max) {
            var len = max - min + 1;
            var rangeV = new exports.IntVector({ "vals": len });
            for (var elN = 0; elN &lt; len; elN++) {
                rangeV[elN] = elN + min;
            }
            return rangeV;
        };

    	//////// METHODS

        /**
         * Squares the values in vector.
         * @param {number | module:la.Vector} x - The value/vector.
         * @returns {number | module:la.Vector}
         * &lt;br> 1. If `x` is a number, returns square of `x`.
         * &lt;br> 2. If `x` is a {@link module:la.Vector}, returns a {@link module:la.Vector}, where the i-th value of the vector is the square of `x[i]`.
         * @example
         * // import la module
         * var la = require('qminer').la;
         * // create a vector
         * var vec = new la.Vector([1, 2, 3]);
         * // square the values of the vector
         * // returns the vector containing  the values 1, 4, 9
         * var sqr = la.square(vec);
         */
        exports.square = function(x) {
            if (typeof x.length == "undefined") {
                return x * x;
            }
            var res = new exports.Vector(x);
            for (var i = 0; i &lt; x.length; i++) {
                res[i] = x[i] * x[i];
            }
            return res;
        };

        /**
        * Returns a JS array of indices `idxArray` that correspond to the max elements in each column of dense matrix. The resulting array has one element for vector input.
        * @param {(module:la.Matrix | module:la.Vector)} X - The matrix or vector.
        * @returns {Array&lt;number>} Array of indexes where maximum is found, one for each column.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a dense matrix
        * var mat = new la.Matrix([[1, 2], [2, 0]]);
        * // get the indices of the maximum elements in each column of mat
        * // returns the array:
        * // [1, 0]
        * la.findMaxIdx(mat);
        */
        exports.findMaxIdx = function (X) {
            var idxv = new Array();
            // X is a dense matrix
            if (typeof X.cols !== "undefined") {
                var cols = X.cols;
                for (var colN = 0; colN &lt; cols; colN++) {
                    idxv.push(X.colMaxIdx(colN));
                }
            }
            // X is a dense vector
            if (typeof X.length !== "undefined") {
                idxv.push(X.getMaxIdx());
            }
            return idxv;
        };

        /**
        * Computes and returns the pairwise squared euclidean distances between columns of `X1` and `X2` (`mat3[i,j] = ||mat(:,i) - mat2(:,j)||^2`).
        * @param {module:la.Matrix} X1 - First matrix.
        * @param {module:la.Matrix} X2 - Second matrix.
        * @returns {module:la.Matrix} Matrix with `X1.cols` rows and `X2.cols` columns containing squared euclidean distances.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // construct two input matrices
        * var X1 = new la.Matrix([[1,2], [2,0]]);
        * var X2 = new la.Matrix([[1,0.5,0],[0,-0.5,-1]]);
        * // get the pairwise squared distance between the matrices
        * // returns the matrix:
        * // 4 6.5 10
        * // 1 2.5 5
        * la.pdist2(X1, X2);
        */
        exports.pdist2 = function (X1, X2) {
            var snorm1 = exports.square(X1.colNorms());
            var snorm2 = exports.square(X2.colNorms());
            var ones_1 = exports.ones(X1.cols);
            var ones_2 = exports.ones(X2.cols);
            var D = (X1.multiplyT(X2).multiply(-2)).plus(snorm1.outer(ones_2)).plus(ones_1.outer(snorm2));
            return D;
        }

        ///////// ALGORITHMS

        /**
        * Calculates the inverse matrix with SVD.
        * @param {module:la.Matrix} mat - The matrix we want to inverse.
        * @returns {module:la.Matrix} The inverse matrix of `mat`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a random matrix
        * var mat = new la.Matrix({ rows: 5, cols: 5, random: true });
        * // get the inverse of mat
        * var inv = la.inverseSVD(mat);
        */
        exports.inverseSVD = function (mat) {
            var k = Math.min(mat.rows, mat.cols);
            var svdRes = exports.svd(mat, k, { "iter": 10, "tol": 1E-15 });  // returns U, s and V
            var B = new exports.Matrix({ "cols": mat.cols, "rows": mat.rows });

            // http://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_pseudoinverse#Singular_value_decomposition_.28SVD.29
            var tol = 1E-16 * Math.max(mat.cols, mat.rows) * svdRes.s.at(svdRes.s.getMaxIdx());

            // calculate reciprocal values for diagonal matrix = inverse diagonal
            for (i = 0; i &lt; svdRes.s.length; i++) {
                if (svdRes.s.at(i) > tol) svdRes.s.put(i, 1 / svdRes.s.at(i));
                else svdRes.s.put(0);
            }

            var sum;

            for (i = 0; i &lt; svdRes.U.cols; i++) {
                for (j = 0; j &lt; svdRes.V.rows; j++) {
                    sum = 0;
                    for (k = 0; k &lt; svdRes.U.cols; k++) {
                        if (svdRes.s.at(k) != 0) {
                            sum += svdRes.s.at(k) * svdRes.V.at(i, k) * svdRes.U.at(j, k);
                        }
                    }
                    B.put(i, j, sum);
                }
            }
            return B;
        }

        /**
        * Solves the PSD symmetric system: A x = b, where A is a positive-definite symmetric matrix.
        * @param {(module:la.Matrix | module:la.SparseMatrix)} A - The matrix on the left-hand side of the system.
        * @param {module:la.Vector} b - The vector on the right-hand side of the system.
        * @param {module:la.Vector} [x] - Current solution. Default is a vector of zeros.
        * @param {boolean} [verbose=false] - If true, console logs the residuum value.
        * @returns {module:la.Vector} Solution to the system.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a positive-definite symmetric matrix
        * var vecTemp = new la.Vector([1, 2, 3]);
        * var mat = vecTemp.diag();
        * // create the right-hand side vector
        * var vec = new la.Vector([0.5, 3, -2]);
        * // solve the PSD symmetric system
        * var x = la.conjgrad(mat, vec);
        */
        exports.conjgrad = function (A, b, x, verbose) {
            verbose = verbose === undefined ? false : verbose;
        	x = x || new exports.Vector({vals: A.cols});
            var r = b.minus(A.multiply(x));
            var p = new exports.Vector(r); //clone
            var rsold = r.inner(r);
            for (var i = 0; i &lt; 2 * x.length; i++) {
                var Ap = A.multiply(p);
                var alpha = rsold / Ap.inner(p);
                x = x.plus(p.multiply(alpha));
                r = r.minus(Ap.multiply(alpha));
                var rsnew = r.inner(r);
                if (verbose) {
                    console.log("resid = " + rsnew);
                }
                if (Math.sqrt(rsnew) &lt; 1e-6) {
                    break;
                }
                p = r.plus(p.multiply(rsnew / rsold));
                rsold = rsnew;
            }
            return x;
        }

    /**
     * Copyright (c) 2015, Jozef Stefan Institute, Quintelligence d.o.o. and contributors
     * All rights reserved.
     *
     * This source code is licensed under the FreeBSD license found in the
     * LICENSE file in the root directory of this source tree.
     */
    /**
    * Vector - array of doubles.
    * @classdesc The number vector representation. Wraps a C++ array.
    * @class
    * @param {(Array.&lt;number> | module:la.Vector)} [arg] - Constructor arguments. There are two ways of constructing:
    * &lt;br>1. using an array of vector elements. Example: using `[1, 2, 3]` creates a vector of length 3,
    * &lt;br>2. using a vector (copy constructor).
    * @example
    * var la = require('qminer').la;
    * // create a new empty vector
    * var vec = new la.Vector();
    * // create a new vector
    * var vec2 = new la.Vector([1, 2, 3]);
    */
     exports.Vector = function() { return Object.create(require('qminer').la.Vector.prototype); }
     var VectorDefaultVal = 0.0; // for intellisense
    /**
        * Returns element at index.
        * @param {number} index - Element index (zero-based).
        * @returns {number} Vector element.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // get the element at index 1
        * var el = vec[1];
        */
     exports.Vector.prototype.at = function(number) { return VectorDefaultVal; }
    /**
        * Returns a subvector.
        * @param {(Array.&lt;number> | module:la.IntVector)} arg - Index array or vector. Indices can repeat (zero based).
        * @returns {module:la.Vector} Subvector, where the i-th element is the `arg[i]`-th element of the instance.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // get the subvector of the first two elements
        * var subvec = vec.subVec([0, 1]);
        */
     exports.Vector.prototype.subVec = function (arg) { return Object.create(this); }
    /**
        * Sets an element in vector.
        * @param {number} idx - Index (zero based).
        * @param {number} val - Element value.
        * @returns {module:la.Vector} Self. The values at index `idx` has been changed to `val`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // set the first element to 10
        * vec.put(0, 10);
        */
     exports.Vector.prototype.put = function (idx, val) { return this;}
    /**
        * Adds an element to the end of the vector.
        * @param {number} val - The element added to the vector.
        * @returns {number} The new length property of the object upon which the method was called.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // push an element to the vector
        * vec.push(10);
        */
     exports.Vector.prototype.push = function (val) { return 0; }
    /**
        * Changes the vector by removing and adding elements.
        * @param {number} start - Index at which to start changing the array.
        * @param {number} deleteCount - Number of elements to be removed.
        * @param {...number} [itemN] - The element(s) to be add to the array. If no elements are given, splice() will only remove elements from the array.
        * @returns {module:la.Vector} Self. The selected elements are removed/replaced.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // splice the vector by removing the last two elements and adding 4, 5
        * vec.splice(1, 2, 4, 5)// returns vector [1, 4, 5]
        */
     exports.Vector.prototype.splice = function (start, deleteCount, itemN) { return this; }
    /**
        * Adds elements to the beginning of the vector.
        * @param {...number} args - One or more elements to be added to the vector.
        * @returns {number} The new length of vector.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // add two elements to the beggining of the vector
        * var len = vec.unshift(4, 5); // returns 5
        */
     exports.Vector.prototype.unshift = function (args) { return 0; }
    /**
        * Appends a second vector to the first one.
        * @param {module:la.Vector} vec - The appended vector.
        * @returns {number} The new length property of the vectors.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create two new vectors
        * var vec = new la.Vector([1, 2, 3]);
        * var vec2 = new la.Vector([4, 5]);
        * // append the two vectors
        * vec.pushV(vec2);
        */
     exports.Vector.prototype.pushV = function (vec) { return 0; }
    /**
        * Sums the elements in the vector.
        * @returns {number} The sum of all elements in the instance.
        * @example
        * // import la modules
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // sum all the elements of the vector
        * var sum = vec.sum();
        */
     exports.Vector.prototype.sum = function () { return VectorDefaultVal; }
    /**
        * Gets the index of the maximal element.
        * @returns {number} Index of the maximal element in the vector.
        * // import la modules
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // get the index of the maximum value
        * var idx = vec.getMaxIdx();
        *
        */
     exports.Vector.prototype.getMaxIdx = function () { return 0; }
    /**
        * Vector sort comparator callback.
        * @callback vectorCompareCb
        * @param {number} arg1 - First argument.
        * @param {number} arg2 - Second argument.
        * @returns {(number | boolean)} If `vectorCompareCb(arg1, arg2)` is less than 0 or false, sort `arg1` to a lower index than `arg2`, i.e. `arg1` comes first.
        */
    /**
        * Sorts the vector (in place operation).
        * @param {(module:la~vectorCompareCb | boolean)} [arg] - Sort callback or a boolean ascend flag. Default is boolean and true.
        * @returns {module:la.Vector} Self.
        * &lt;br>1. Vector sorted in ascending order, if `arg` is boolean and true.
        * &lt;br>2. Vector sorted in descending order, if `arg` is boolean and false.
        * &lt;br>3. Vector sorted by using the comparator callback, if `arg` is a {@link module:la~vectorCompareCb}.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([-2.0, 1.0, 3.0]);
        * // sort ascending
        * vec.sort(); // sorts to: [-2.0, 1.0, 3.0]
        * // sort using callback
        * vec.sort(function(arg1, arg2) { return Math.abs(arg1) - Math.abs(arg2); }); // sorts to: [1.0, -2.0, 3.0]
        */
     exports.Vector.prototype.sort = function (bool) { return this; }
    /**
        * Sorts the vector and returns the sorted vector as well as the permutation.
        * @param {boolean} [asc = true] - Sort in ascending order flag.
        * @returns {Object} The object `VectorSortResult` containing the properties:
        * &lt;br> `VectorSortResult.vec` - The sorted vector,
        * &lt;br> `VectorSortResult.perm` - Permutation vector, where `VectorSortResult.vec[i] = instanceVector[VectorSortResult.perm[i]]`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([-2.0, 1.0, 3.0]);
        * // sort ascending
        * var result = vec.sortPerm();
        * result.vec;  // [-2.0, 1.0, 3.0]
        * result.perm; // permutation index vector
        */
     exports.Vector.prototype.sortPerm = function (asc) { return {vec: Object.create(this), perm: Object.create(require('qminer').la.IntVector.prototype) }; }
    /**
        * Randomly reorders the elements of the vector (inplace).
        * @returns {module:la.Vector} Self. The elements are randomly reordered.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([-2.0, 1.0, 3.0]);
        * // shuffle the elements
        * vec.shuffle();
        */
     exports.Vector.prototype.shuffle = function () { return this; }
    /**
        * Deletes elements with sprecific index or more.
        * @param {number} idx - Index (zero based).
        * @returns {module:la.Vector} Self after truncating.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // trunc all elements with index 1 or more
        * vec.trunc(1); // returns vector [1]
        */
     exports.Vector.prototype.trunc = function (idx) { return this; }
    /**
        * Creates a dense matrix A by multiplying two vectors x and y: `A = x * y^T`.
        * @param {module:la.Vector} vec - Second vector.
        * @returns {module:la.Matrix} Matrix obtained by the outer product of the instance and second vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 2, 3]);
        * var y = new la.Vector([4, 5]);
        * // create the outer product of these vectors
        * var A = x.outer(y); // creates the dense matrix [[4, 5], [8, 10], [12, 15]]
        */
     exports.Vector.prototype.outer = function (vec) { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Computes the inner product.
        * @param {module:la.Vector} vec - Other vector.
        * @returns {number} Inner product between the instance and the other vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 2, 3]);
        * var y = new la.Vector([4, 5, -1]);
        * // get the inner product of the two vectors
        * var prod = x.inner(y); // returns 11
        */
     exports.Vector.prototype.inner = function(vec) { return 0; }
    /**
        * Returns the cosine between the two vectors.
        * @param {module:la.Vector} vec - Second vector.
        * @returns {number} The cosine between the two vectors.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 0]);
        * var y = new la.Vector([0, 1]);
        * // calculate the cosine between those two vectors
        * var num = x.cosine(y); // returns 0
        */
     exports.Vector.prototype.cosine = function (vec) { return 0.0; }
    /**
        * Vector addition.
        * @param {module:la.Vector} vec - Second vector.
        * @returns {module:la.Vector} Sum of the instance and the second vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 2, 3]);
        * var y = new la.Vector([4, 5, -1]);
        * // sum the vectors
        * var z = x.plus(y);
        */
     exports.Vector.prototype.plus = function (vec) { return Object.create(this); }
    /**
        * Vector substraction.
        * @param {module:la.Vector} vec - Second vector.
        * @returns {module:la.Vector} The difference of the instance and the other vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 2, 3]);
        * var y = new la.Vector([4, 5, -1]);
        * // substract the vectors
        * var z = x.minus(y);
        */
     exports.Vector.prototype.minus = function (vec) { return Object.create(this); }
    /**
        * Multiplies the vector with a scalar.
        * @param {number} val - Scalar.
        * @returns {module:la.Vector} Product of the vector and scalar.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var x = new la.Vector([4, 5, -1]);
        * // multiply the vector with the scalar 3
        * var y = x.multiply(3);
        */
     exports.Vector.prototype.multiply = function (val) { return Object.create(this); }
    /**
        * Normalizes vector.
        * @returns {module:la.Vector} Self. The vector is normalized.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var x = new la.Vector([4, 5, -1]);
        * // normalize the vector
        * x.normalize();
        */
     exports.Vector.prototype.normalize = function () { return this; }
    /**
        * Gives the length of vector. Type `number`.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var x = new la.Vector([1, 2, 3]);
        * // get the length of the vector
        * var len = x.length; // returns 3
        */
     exports.Vector.prototype.length = 0;
    /**
        * Returns the vector as string.
        * @returns {string} String representation.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // create vector as string
        * vec.toString(); // returns '1, 2, 3'
        */
     exports.Vector.prototype.toString = function () { return ''; }
    /**
        * Creates a dense diagonal matrix out of the vector.
        * @returns{module:la.Matrix} Diagonal matrix, where the (i, i)-th element is the i-th element of vector.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create a dense matrix with the diagonal equal to vec
        * var mat = vec.diag();
        */
     exports.Vector.prototype.diag = function () { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Creates a sparse diagonal matrix out of the vector.
        * @returns {module:la.SparseMatrix} Diagonal matrix, where the (i, i)-th element is the i-th element of vector.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create a sparse matrix with the diagonal equal to vec
        * var mat = vec.spDiag();
        */
     exports.Vector.prototype.spDiag = function () { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Calculates the norm of the vector.
        * @returns {number} The norm of the vector.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // get the norm of the vector
        * var norm = vec.norm();
        */
     exports.Vector.prototype.norm = function () { return 0.0; }
    /**
        * Creates the sparse vector representation of the vector.
        * @returns {module:la.SparseVector} The sparse vector representation.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create the sparse representation of the vector
        * var spVec = vec.sparse();
        */
     exports.Vector.prototype.sparse = function () { return Object.create(require('qminer').la.SparseVector.prototype); }
    /**
        * Creates a matrix with a single column that is equal to the vector.
        * @returns {module:la.Matrix} The matrix with a single column that is equal to the instance.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create a matrix representation of the vector
        * var mat = vec.toMat();
        */
     exports.Vector.prototype.toMat = function () { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Saves the vector as output stream (binary serialization).
        * @param {module:fs.FOut} fout - Output stream.
        * @returns {module:fs.FOut} The output stream `fout`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // open write stream
        * var fout = fs.openWrite('vec.dat');
        * // save vector and close write stream
        * vec.save(fout).close();
        */
     exports.Vector.prototype.save = function (fout) {  return Object.create(require('qminer').fs.FOut.prototype); }
    /**
        * Loads the vector from input stream (binary deserialization).
        * @param {module:fs.FIn} fin - Input stream.
        * @returns {module:la.Vector} Self. The vector is filled using the input stream `fin`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create an empty vector
        * var vec = new la.Vector();
        * // open a read stream
        * var fin = fs.openRead('vec.dat');
        * // load the vector
        * vec.load(fin);
        */
     exports.Vector.prototype.load = function (fin) { return this; }
    /**
        * Saves the vector as output stream (ascii serialization).
        * @param {module:fs.FOut} fout - Output stream.
        * @returns {module:fs.FOut} The output stream `fout`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([1, 2, 3]);
        * // open write stream
        * var fout = fs.openWrite('vec.dat');
        * // save matrix and close write stream
        * vec.saveascii(fout).close();
        */
     exports.Vector.prototype.saveascii = function (fout) {  return Object.create(require('qminer').fs.FOut.prototype); }
    /**
        * Loads the vector from input stream (ascii deserialization).
        * @param {module:fs.FIn} fin - Input stream.
        * @returns {module:la.Vector} Self. The vector is filled using the input stream `fin`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create an empty vector
        * var vec = new la.Vector();
        * // open a read stream
        * var fin = fs.openRead('vec.dat');
        * // load the matrix
        * vec.loadascii(fin);
        */
     exports.Vector.prototype.loadascii = function (fin) { return this; }

    /**
     * Copyright (c) 2015, Jozef Stefan Institute, Quintelligence d.o.o. and contributors
     * All rights reserved.
     *
     * This source code is licensed under the FreeBSD license found in the
     * LICENSE file in the root directory of this source tree.
     */
    /**
    * Vector - array of strings.
    * @classdesc The string vector representation. Wraps a C++ array.
    * @class
    * @param {(Array.&lt;string> | module:la.StrVector)} [arg] - Constructor arguments. There are two ways of constructing:
    * &lt;br>1. using an array of vector elements. Example: using `['a', 'b', 'c']` creates a vector of length 3,
    * &lt;br>2. using a vector (copy constructor).
    * @example
    * var la = require('qminer').la;
    * // create a new empty vector
    * var vec = new la.StrVector();
    * // create a new vector
    * var vec2 = new la.StrVector(['a', 'b', 'c']);
    */
     exports.StrVector = function() { return Object.create(require('qminer').la.StrVector.prototype); }
     var StrVectorDefaultVal = ''; // for intellisense
    /**
        * Returns element at index.
        * @param {number} index - Element index (zero-based).
        * @returns {string} Vector element.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['a', 'b', 'c']);
        * // get the element at index 1
        * var el = vec[1];
        */
     exports.StrVector.prototype.at = function(number) { return StrVectorDefaultVal; }
    /**
        * Returns a subvector.
        * @param {(Array.&lt;number> | module:la.IntVector)} arg - Index array or vector. Indices can repeat (zero based).
        * @returns {module:la.StrVector} Subvector, where the i-th element is the `arg[i]`-th element of the instance.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['a', 'b', 'c']);
        * // get the subvector of the first two elements
        * var subvec = vec.subVec([0, 1]);
        */
     exports.StrVector.prototype.subVec = function (arg) { return Object.create(this); }
    /**
        * Sets an element in vector.
        * @param {number} idx - Index (zero based).
        * @param {string} val - Element value.
        * @returns {module:la.StrVector} Self. The values at index `idx` has been changed to `val`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['a', 'b', 'c']);
        * // set the first element to 'xyz'
        * vec.put(0, 'xyz');
        */
     exports.StrVector.prototype.put = function (idx, val) { return this;}
    /**
        * Adds an element to the end of the vector.
        * @param {string} val - The element added to the vector.
        * @returns {number} The new length property of the object upon which the method was called.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['a', 'b', 'c']);
        * // push an element to the vector
        * vec.push('xyz');
        */
     exports.StrVector.prototype.push = function (val) { return 0; }
    /**
        * Changes the vector by removing and adding elements.
        * @param {number} start - Index at which to start changing the array.
        * @param {number} deleteCount - Number of elements to be removed.
        * @param {...number} [itemN] - The element(s) to be add to the array. If no elements are given, splice() will only remove elements from the array.
        * @returns {module:la.StrVector} Self. The selected elements are removed/replaced.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['a', 'b', 'c']);
        * // splice the vector by removing the last two elements and adding 'd', 'e'
        * vec.splice(1, 2, 'd', 'e')// returns vector ['a', 'd', 'e']
        */
     exports.StrVector.prototype.splice = function (start, deleteCount, itemN) { return this; }
    /**
        * Adds elements to the beginning of the vector.
        * @param {...string} args - One or more elements to be added to the vector.
        * @returns {number} The new length of vector.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['a', 'b', 'c']);
        * // add two elements to the beggining of the vector
        * var len = vec.unshift('d', 'e'); // returns 5
        */
     exports.StrVector.prototype.unshift = function (args) { return 0; }
    /**
        * Appends a second vector to the first one.
        * @param {module:la.StrVector} vec - The appended vector.
        * @returns {number} The new length property of the vectors.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create two new vectors
        * var vec = new la.StrVector(['a', 'b', 'c']);
        * var vec2 = new la.StrVector(['d', 'e']);
        * // append the two vectors
        * vec.pushV(vec2);
        */
     exports.StrVector.prototype.pushV = function (vec) { return 0; }
    /**
        * Sums the elements in the vector.
        * @returns {number} The sum of all elements in the instance.
        * @example
        * // import la modules
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['a', 'b', 'c']);
        * // sum all the elements of the vector
        * var sum = vec.sum();
        */
     skip.exports.StrVector.prototype.sum = function () { return StrVectorDefaultVal; }
    /**
        * Gets the index of the maximal element.
        * @returns {number} Index of the maximal element in the vector.
        * // import la modules
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['a', 'b', 'c']);
        * // get the index of the maximum value
        * var idx = vec.getMaxIdx();
        *
        */
     skip.exports.StrVector.prototype.getMaxIdx = function () { return 0; }
    /**
        * Vector sort comparator callback.
        * @callback strVectorCompareCb
        * @param {string} arg1 - First argument.
        * @param {string} arg2 - Second argument.
        * @returns {(number | boolean)} If `strVectorCompareCb(arg1, arg2)` is less than 0 or false, sort `arg1` to a lower index than `arg2`, i.e. `arg1` comes first.
        */
    /**
        * Sorts the vector (in place operation).
        * @param {(module:la~strVectorCompareCb | boolean)} [arg] - Sort callback or a boolean ascend flag. Default is boolean and true.
        * @returns {module:la.StrVector} Self.
        * &lt;br>1. Vector sorted in ascending order, if `arg` is boolean and true.
        * &lt;br>2. Vector sorted in descending order, if `arg` is boolean and false.
        * &lt;br>3. Vector sorted by using the comparator callback, if `arg` is a {@link module:la~strVectorCompareCb}.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['asd', 'z', 'kkkk']);
        * // sort ascending
        * vec.sort(); // sorts to: ['asd', 'kkkk', 'z']
        * // sort using callback
        * vec.sort(function(arg1, arg2) { return arg1.length - arg2.length; }); // sorts to: ['z', 'asd', 'kkkk']
        */
     skip.exports.StrVector.prototype.sort = function (bool) { return this; }
    /**
        * Sorts the vector and returns the sorted vector as well as the permutation.
        * @param {boolean} [asc = true] - Sort in ascending order flag.
        * @returns {Object} The object `StrVectorSortResult` containing the properties:
        * &lt;br> `StrVectorSortResult.vec` - The sorted vector,
        * &lt;br> `StrVectorSortResult.perm` - Permutation vector, where `StrVectorSortResult.vec[i] = instanceVector[StrVectorSortResult.perm[i]]`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['asd', 'z', 'kkkk']);
        * // sort ascending
        * var result = vec.sortPerm();
        * result.vec;  // ['asd', 'kkkk', 'z']
        * result.perm; // permutation index vector
        */
     skip.exports.StrVector.prototype.sortPerm = function (asc) { return {vec: Object.create(this), perm: Object.create(require('qminer').la.IntVector.prototype) }; }
    /**
        * Randomly reorders the elements of the vector (inplace).
        * @returns {module:la.StrVector} Self. The elements are randomly reordered.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['asd', 'z', 'kkkk']);
        * // shuffle the elements
        * vec.shuffle();
        */
     exports.StrVector.prototype.shuffle = function () { return this; }
    /**
        * Deletes elements with sprecific index or more.
        * @param {string} idx - Index (zero based).
        * @returns {module:la.StrVector} Self after truncating.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['a', 'b', 'c']);
        * // trunc all elements with index 1 or more
        * vec.trunc(1); // returns vector ['a']
        */
     exports.StrVector.prototype.trunc = function (idx) { return this; }
    /**
        * Creates a dense matrix A by multiplying two vectors x and y: `A = x * y^T`.
        * @param {module:la.StrVector} vec - Second vector.
        * @returns {module:la.Matrix} Matrix obtained by the outer product of the instance and second vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.StrVector([1, 2, 3]);
        * var y = new la.StrVector([4, 5]);
        * // create the outer product of these vectors
        * var A = x.outer(y); // creates the dense matrix [[4, 5], [8, 10], [12, 15]]
        */
     skip.exports.StrVector.prototype.outer = function (vec) { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Computes the inner product.
        * @param {module:la.Vector} vec - Other vector.
        * @returns {number} Inner product between the instance and the other vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 2, 3]);
        * var y = new la.Vector([4, 5, -1]);
        * // get the inner product of the two vectors
        * var prod = x.inner(y); // returns 11
        */
     skip.exports.Vector.prototype.inner = function(vec) { return 0; }
    /**
        * Returns the cosine between the two vectors.
        * @param {module:la.Vector} vec - Second vector.
        * @returns {number} The cosine between the two vectors.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 0]);
        * var y = new la.Vector([0, 1]);
        * // calculate the cosine between those two vectors
        * var num = x.cosine(y); // returns 0
        */
     skip.exports.Vector.prototype.cosine = function (vec) { return 0.0; }
    /**
        * Vector addition.
        * @param {module:la.Vector} vec - Second vector.
        * @returns {module:la.Vector} Sum of the instance and the second vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 2, 3]);
        * var y = new la.Vector([4, 5, -1]);
        * // sum the vectors
        * var z = x.plus(y);
        */
     skip.exports.Vector.prototype.plus = function (vec) { return Object.create(this); }
    /**
        * Vector substraction.
        * @param {module:la.Vector} vec - Second vector.
        * @returns {module:la.Vector} The difference of the instance and the other vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 2, 3]);
        * var y = new la.Vector([4, 5, -1]);
        * // substract the vectors
        * var z = x.minus(y);
        */
     skip.exports.Vector.prototype.minus = function (vec) { return Object.create(this); }
    /**
        * Multiplies the vector with a scalar.
        * @param {number} val - Scalar.
        * @returns {module:la.Vector} Product of the vector and scalar.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var x = new la.Vector([4, 5, -1]);
        * // multiply the vector with the scalar 3
        * var y = x.multiply(3);
        */
     skip.exports.Vector.prototype.multiply = function (val) { return Object.create(this); }
    /**
        * Normalizes vector.
        * @returns {module:la.Vector} Self. The vector is normalized.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var x = new la.Vector([4, 5, -1]);
        * // normalize the vector
        * x.normalize();
        */
     skip.exports.Vector.prototype.normalize = function () { return this; }
    /**
        * Gives the length of vector. Type `number`.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var x = new la.StrVector(['a', 'b', 'c']);
        * // get the length of the vector
        * var len = x.length; // returns 3
        */
     exports.StrVector.prototype.length = 0;
    /**
        * Returns the vector as string.
        * @returns {string} String representation.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['a', 'b', 'c']);
        * // create vector as string
        * vec.toString(); // returns 'a, b, c'
        */
     exports.StrVector.prototype.toString = function () { return ''; }
    /**
        * Creates a dense diagonal matrix out of the vector.
        * @returns{module:la.Matrix} Diagonal matrix, where the (i, i)-th element is the i-th element of vector.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create a dense matrix with the diagonal equal to vec
        * var mat = vec.diag();
        */
     skip.exports.Vector.prototype.diag = function () { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Creates a sparse diagonal matrix out of the vector.
        * @returns {module:la.SparseMatrix} Diagonal matrix, where the (i, i)-th element is the i-th element of vector.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create a sparse matrix with the diagonal equal to vec
        * var mat = vec.spDiag();
        */
     skip.exports.StrVector.prototype.spDiag = function () { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Calculates the norm of the vector.
        * @returns {number} The norm of the vector.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // get the norm of the vector
        * var norm = vec.norm();
        */
     skip.exports.Vector.prototype.norm = function () { return 0.0; }
    /**
        * Creates the sparse vector representation of the vector.
        * @returns {module:la.SparseVector} The sparse vector representation.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create the sparse representation of the vector
        * var spVec = vec.sparse();
        */
     skip.exports.Vector.prototype.sparse = function () { return Object.create(require('qminer').la.SparseVector.prototype); }
    /**
        * Creates a matrix with a single column that is equal to the vector.
        * @returns {module:la.Matrix} The matrix with a single column that is equal to the instance.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create a matrix representation of the vector
        * var mat = vec.toMat();
        */
     skip.exports.Vector.prototype.toMat = function () { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Saves the vector as output stream (binary serialization).
        * @param {module:fs.FOut} fout - Output stream.
        * @returns {module:fs.FOut} The output stream `fout`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['a', 'b', 'c']);
        * // open write stream
        * var fout = fs.openWrite('vec.dat');
        * // save vector and close write stream
        * vec.save(fout).close();
        */
     exports.StrVector.prototype.save = function (fout) {  return Object.create(require('qminer').fs.FOut.prototype); }
    /**
        * Loads the vector from input stream (binary deserialization).
        * @param {module:fs.FIn} fin - Input stream.
        * @returns {module:la.StrVector} Self. The vector is filled using the input stream `fin`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create an empty vector
        * var vec = new la.StrVector();
        * // open a read stream
        * var fin = fs.openRead('vec.dat');
        * // load the vector
        * vec.load(fin);
        */
     exports.StrVector.prototype.load = function (fin) { return this; }
    /**
        * Saves the vector as output stream (ascii serialization).
        * @param {module:fs.FOut} fout - Output stream.
        * @returns {module:fs.FOut} The output stream `fout`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.StrVector(['a', 'b', 'c']);
        * // open write stream
        * var fout = fs.openWrite('vec.dat');
        * // save matrix and close write stream
        * vec.saveascii(fout).close();
        */
     exports.StrVector.prototype.saveascii = function (fout) {  return Object.create(require('qminer').fs.FOut.prototype); }
    /**
        * Loads the vector from input stream (ascii deserialization).
        * @param {module:fs.FIn} fin - Input stream.
        * @returns {module:la.StrVector} Self. The vector is filled using the input stream `fin`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create an empty vector
        * var vec = new la.StrVector();
        * // open a read stream
        * var fin = fs.openRead('vec.dat');
        * // load the matrix
        * vec.loadascii(fin);
        */
     exports.StrVector.prototype.loadascii = function (fin) { return this; }

    /**
     * Copyright (c) 2015, Jozef Stefan Institute, Quintelligence d.o.o. and contributors
     * All rights reserved.
     *
     * This source code is licensed under the FreeBSD license found in the
     * LICENSE file in the root directory of this source tree.
     */
    /**
    * Vector - array of integers.
    * @classdesc The number vector representation. Wraps a C++ array.
    * @class
    * @param {(Array.&lt;number> | module:la.IntVector)} [arg] - Constructor arguments. There are two ways of constructing:
    * &lt;br>1. using an array of vector elements. Example: using `[1, 2, 3]` creates a vector of length 3,
    * &lt;br>2. using a vector (copy constructor).
    * @example
    * var la = require('qminer').la;
    * // create a new empty vector
    * var vec = new la.IntVector();
    * // create a new vector
    * var vec2 = new la.IntVector([1, 2, 3]);
    */
     exports.IntVector = function() { return Object.create(require('qminer').la.IntVector.prototype); }
     var IntVectorDefaultVal = 0; // for intellisense
    /**
        * Returns element at index.
        * @param {number} index - Element index (zero-based).
        * @returns {number} Vector element.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([1, 2, 3]);
        * // get the element at index 1
        * var el = vec[1];
        */
     exports.IntVector.prototype.at = function(number) { return IntVectorDefaultVal; }
    /**
        * Returns a subvector.
        * @param {(Array.&lt;number> | module:la.IntVector)} arg - Index array or vector. Indices can repeat (zero based).
        * @returns {module:la.IntVector} Subvector, where the i-th element is the `arg[i]`-th element of the instance.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([1, 2, 3]);
        * // get the subvector of the first two elements
        * var subvec = vec.subVec([0, 1]);
        */
     exports.IntVector.prototype.subVec = function (arg) { return Object.create(this); }
    /**
        * Sets an element in vector.
        * @param {number} idx - Index (zero based).
        * @param {number} val - Element value.
        * @returns {module:la.IntVector} Self. The values at index `idx` has been changed to `val`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([1, 2, 3]);
        * // set the first element to 10
        * vec.put(0, 10);
        */
     exports.IntVector.prototype.put = function (idx, val) { return this;}
    /**
        * Adds an element to the end of the vector.
        * @param {number} val - The element added to the vector.
        * @returns {number} The new length property of the object upon which the method was called.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([1, 2, 3]);
        * // push an element to the vector
        * vec.push(10);
        */
     exports.IntVector.prototype.push = function (val) { return 0; }
    /**
        * Changes the vector by removing and adding elements.
        * @param {number} start - Index at which to start changing the array.
        * @param {number} deleteCount - Number of elements to be removed.
        * @param {...number} [itemN] - The element(s) to be add to the array. If no elements are given, splice() will only remove elements from the array.
        * @returns {module:la.IntVector} Self. The selected elements are removed/replaced.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([1, 2, 3]);
        * // splice the vector by removing the last two elements and adding 4, 5
        * vec.splice(1, 2, 4, 5)// returns vector [1, 4, 5]
        */
     exports.IntVector.prototype.splice = function (start, deleteCount, itemN) { return this; }
    /**
        * Adds elements to the beginning of the vector.
        * @param {...number} args - One or more elements to be added to the vector.
        * @returns {number} The new length of vector.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([1, 2, 3]);
        * // add two elements to the beggining of the vector
        * var len = vec.unshift(4, 5); // returns 5
        */
     exports.IntVector.prototype.unshift = function (args) { return 0; }
    /**
        * Appends a second vector to the first one.
        * @param {module:la.IntVector} vec - The appended vector.
        * @returns {number} The new length property of the vectors.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create two new vectors
        * var vec = new la.IntVector([1, 2, 3]);
        * var vec2 = new la.IntVector([4, 5]);
        * // append the two vectors
        * vec.pushV(vec2);
        */
     exports.IntVector.prototype.pushV = function (vec) { return 0; }
    /**
        * Sums the elements in the vector.
        * @returns {number} The sum of all elements in the instance.
        * @example
        * // import la modules
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([1, 2, 3]);
        * // sum all the elements of the vector
        * var sum = vec.sum();
        */
     exports.IntVector.prototype.sum = function () { return IntVectorDefaultVal; }
    /**
        * Gets the index of the maximal element.
        * @returns {number} Index of the maximal element in the vector.
        * // import la modules
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([1, 2, 3]);
        * // get the index of the maximum value
        * var idx = vec.getMaxIdx();
        *
        */
     exports.IntVector.prototype.getMaxIdx = function () { return 0; }
    /**
        * Vector sort comparator callback.
        * @callback intVectorCompareCb
        * @param {number} arg1 - First argument.
        * @param {number} arg2 - Second argument.
        * @returns {(number | boolean)} If `intVectorCompareCb(arg1, arg2)` is less than 0 or false, sort `arg1` to a lower index than `arg2`, i.e. `arg1` comes first.
        */
    /**
        * Sorts the vector (in place operation).
        * @param {(module:la~intVectorCompareCb | boolean)} [arg] - Sort callback or a boolean ascend flag. Default is boolean and true.
        * @returns {module:la.IntVector} Self.
        * &lt;br>1. Vector sorted in ascending order, if `arg` is boolean and true.
        * &lt;br>2. Vector sorted in descending order, if `arg` is boolean and false.
        * &lt;br>3. Vector sorted by using the comparator callback, if `arg` is a {@link module:la~intVectorCompareCb}.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([-2, 1, 3]);
        * // sort ascending
        * vec.sort(); // sorts to: [-2, 1, 3]
        * // sort using callback
        * vec.sort(function(arg1, arg2) { return Math.abs(arg1) - Math.abs(arg2); }); // sorts to: [1, -2, 3]
        */
     skip.exports.IntVector.prototype.sort = function (bool) { return this; }
    /**
        * Sorts the vector and returns the sorted vector as well as the permutation.
        * @param {boolean} [asc = true] - Sort in ascending order flag.
        * @returns {Object} The object `IntVectorSortResult` containing the properties:
        * &lt;br> `IntVectorSortResult.vec` - The sorted vector,
        * &lt;br> `IntVectorSortResult.perm` - Permutation vector, where `IntVectorSortResult.vec[i] = instanceVector[IntVectorSortResult.perm[i]]`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([-2, 1, 3]);
        * // sort ascending
        * var result = vec.sortPerm();
        * result.vec;  // [-2, 1, 3]
        * result.perm; // permutation index vector
        */
     skip.exports.IntVector.prototype.sortPerm = function (asc) { return {vec: Object.create(this), perm: Object.create(require('qminer').la.IntVector.prototype) }; }
    /**
        * Randomly reorders the elements of the vector (inplace).
        * @returns {module:la.IntVector} Self. The elements are randomly reordered.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([-2, 1, 3]);
        * // shuffle the elements
        * vec.shuffle();
        */
     exports.IntVector.prototype.shuffle = function () { return this; }
    /**
        * Deletes elements with sprecific index or more.
        * @param {number} idx - Index (zero based).
        * @returns {module:la.IntVector} Self after truncating.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([1, 2, 3]);
        * // trunc all elements with index 1 or more
        * vec.trunc(1); // returns vector [1]
        */
     exports.IntVector.prototype.trunc = function (idx) { return this; }
    /**
        * Creates a dense matrix A by multiplying two vectors x and y: `A = x * y^T`.
        * @param {module:la.IntVector} vec - Second vector.
        * @returns {module:la.Matrix} Matrix obtained by the outer product of the instance and second vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.IntVector([1, 2, 3]);
        * var y = new la.IntVector([4, 5]);
        * // create the outer product of these vectors
        * var A = x.outer(y); // creates the dense matrix [[4, 5], [8, 10], [12, 15]]
        */
     skip.exports.IntVector.prototype.outer = function (vec) { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Computes the inner product.
        * @param {module:la.Vector} vec - Other vector.
        * @returns {number} Inner product between the instance and the other vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 2, 3]);
        * var y = new la.Vector([4, 5, -1]);
        * // get the inner product of the two vectors
        * var prod = x.inner(y); // returns 11
        */
     skip.exports.Vector.prototype.inner = function(vec) { return 0; }
    /**
        * Returns the cosine between the two vectors.
        * @param {module:la.Vector} vec - Second vector.
        * @returns {number} The cosine between the two vectors.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 0]);
        * var y = new la.Vector([0, 1]);
        * // calculate the cosine between those two vectors
        * var num = x.cosine(y); // returns 0
        */
     skip.exports.Vector.prototype.cosine = function (vec) { return 0.0; }
    /**
        * Vector addition.
        * @param {module:la.Vector} vec - Second vector.
        * @returns {module:la.Vector} Sum of the instance and the second vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 2, 3]);
        * var y = new la.Vector([4, 5, -1]);
        * // sum the vectors
        * var z = x.plus(y);
        */
     skip.exports.Vector.prototype.plus = function (vec) { return Object.create(this); }
    /**
        * Vector substraction.
        * @param {module:la.Vector} vec - Second vector.
        * @returns {module:la.Vector} The difference of the instance and the other vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 2, 3]);
        * var y = new la.Vector([4, 5, -1]);
        * // substract the vectors
        * var z = x.minus(y);
        */
     skip.exports.Vector.prototype.minus = function (vec) { return Object.create(this); }
    /**
        * Multiplies the vector with a scalar.
        * @param {number} val - Scalar.
        * @returns {module:la.Vector} Product of the vector and scalar.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var x = new la.Vector([4, 5, -1]);
        * // multiply the vector with the scalar 3
        * var y = x.multiply(3);
        */
     skip.exports.Vector.prototype.multiply = function (val) { return Object.create(this); }
    /**
        * Normalizes vector.
        * @returns {module:la.Vector} Self. The vector is normalized.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var x = new la.Vector([4, 5, -1]);
        * // normalize the vector
        * x.normalize();
        */
     skip.exports.Vector.prototype.normalize = function () { return this; }
    /**
        * Gives the length of vector. Type `number`.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var x = new la.IntVector([1, 2, 3]);
        * // get the length of the vector
        * var len = x.length; // returns 3
        */
     exports.IntVector.prototype.length = 0;
    /**
        * Returns the vector as string.
        * @returns {string} String representation.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([1, 2, 3]);
        * // create vector as string
        * vec.toString(); // returns '1, 2, 3'
        */
     exports.IntVector.prototype.toString = function () { return ''; }
    /**
        * Creates a dense diagonal matrix out of the vector.
        * @returns{module:la.Matrix} Diagonal matrix, where the (i, i)-th element is the i-th element of vector.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create a dense matrix with the diagonal equal to vec
        * var mat = vec.diag();
        */
     skip.exports.Vector.prototype.diag = function () { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Creates a sparse diagonal matrix out of the vector.
        * @returns {module:la.SparseMatrix} Diagonal matrix, where the (i, i)-th element is the i-th element of vector.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create a sparse matrix with the diagonal equal to vec
        * var mat = vec.spDiag();
        */
     skip.exports.IntVector.prototype.spDiag = function () { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Calculates the norm of the vector.
        * @returns {number} The norm of the vector.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // get the norm of the vector
        * var norm = vec.norm();
        */
     skip.exports.Vector.prototype.norm = function () { return 0.0; }
    /**
        * Creates the sparse vector representation of the vector.
        * @returns {module:la.SparseVector} The sparse vector representation.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create the sparse representation of the vector
        * var spVec = vec.sparse();
        */
     skip.exports.Vector.prototype.sparse = function () { return Object.create(require('qminer').la.SparseVector.prototype); }
    /**
        * Creates a matrix with a single column that is equal to the vector.
        * @returns {module:la.Matrix} The matrix with a single column that is equal to the instance.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create a matrix representation of the vector
        * var mat = vec.toMat();
        */
     skip.exports.Vector.prototype.toMat = function () { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Saves the vector as output stream (binary serialization).
        * @param {module:fs.FOut} fout - Output stream.
        * @returns {module:fs.FOut} The output stream `fout`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([1, 2, 3]);
        * // open write stream
        * var fout = fs.openWrite('vec.dat');
        * // save vector and close write stream
        * vec.save(fout).close();
        */
     exports.IntVector.prototype.save = function (fout) {  return Object.create(require('qminer').fs.FOut.prototype); }
    /**
        * Loads the vector from input stream (binary deserialization).
        * @param {module:fs.FIn} fin - Input stream.
        * @returns {module:la.IntVector} Self. The vector is filled using the input stream `fin`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create an empty vector
        * var vec = new la.IntVector();
        * // open a read stream
        * var fin = fs.openRead('vec.dat');
        * // load the vector
        * vec.load(fin);
        */
     exports.IntVector.prototype.load = function (fin) { return this; }
    /**
        * Saves the vector as output stream (ascii serialization).
        * @param {module:fs.FOut} fout - Output stream.
        * @returns {module:fs.FOut} The output stream `fout`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.IntVector([1, 2, 3]);
        * // open write stream
        * var fout = fs.openWrite('vec.dat');
        * // save matrix and close write stream
        * vec.saveascii(fout).close();
        */
     exports.IntVector.prototype.saveascii = function (fout) {  return Object.create(require('qminer').fs.FOut.prototype); }
    /**
        * Loads the vector from input stream (ascii deserialization).
        * @param {module:fs.FIn} fin - Input stream.
        * @returns {module:la.IntVector} Self. The vector is filled using the input stream `fin`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create an empty vector
        * var vec = new la.IntVector();
        * // open a read stream
        * var fin = fs.openRead('vec.dat');
        * // load the matrix
        * vec.loadascii(fin);
        */
     exports.IntVector.prototype.loadascii = function (fin) { return this; }

    /**
     * Copyright (c) 2015, Jozef Stefan Institute, Quintelligence d.o.o. and contributors
     * All rights reserved.
     *
     * This source code is licensed under the FreeBSD license found in the
     * LICENSE file in the root directory of this source tree.
     */
    /**
    * Vector - array of boolean.
    * @classdesc The boolean vector representation. Wraps a C++ array.
    * @class
    * @param {(Array.&lt;boolean> | module:la.BoolVector)} [arg] - Constructor arguments. There are two ways of constructing:
    * &lt;br>1. using an array of vector elements. Example: using `[true, true, false]` creates a vector of length 3,
    * &lt;br>2. using a vector (copy constructor).
    * @example
    * var la = require('qminer').la;
    * // create a new empty vector
    * var vec = new la.BoolVector();
    * // create a new vector
    * var vec2 = new la.BoolVector([true, true, false]);
    */
     exports.BoolVector = function() { return Object.create(require('qminer').la.BoolVector.prototype); }
     var BoolVectorDefaultVal = false; // for intellisense
    /**
        * Returns element at index.
        * @param {number} index - Element index (zero-based).
        * @returns {boolean} Vector element.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, true, false]);
        * // get the element at index 1
        * var el = vec[1];
        */
     exports.BoolVector.prototype.at = function(number) { return BoolVectorDefaultVal; }
    /**
        * Returns a subvector.
        * @param {(Array.&lt;number> | module:la.IntVector)} arg - Index array or vector. Indices can repeat (zero based).
        * @returns {module:la.BoolVector} Subvector, where the i-th element is the `arg[i]`-th element of the instance.
        * @skip.example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, true, false]);
        * // get the subvector of the first two elements
        * var subvec = vec.subVec([0, 1]);
        */
     skip.exports.BoolVector.prototype.subVec = function (arg) { return Object.create(this); }
    /**
        * Sets an element in vector.
        * @param {number} idx - Index (zero based).
        * @param {boolean} val - Element value.
        * @returns {module:la.BoolVector} Self. The values at index `idx` has been changed to `val`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, true, false]);
        * // set the first element to false
        * vec.put(0, false);
        */
     exports.BoolVector.prototype.put = function (idx, val) { return this;}
    /**
        * Adds an element to the end of the vector.
        * @param {boolean} val - The element added to the vector.
        * @returns {number} The new length property of the object upon which the method was called.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, true, false]);
        * // push an element to the vector
        * vec.push(false);
        */
     exports.BoolVector.prototype.push = function (val) { return 0; }
    /**
        * Changes the vector by removing and adding elements.
        * @param {number} start - Index at which to start changing the array.
        * @param {number} deleteCount - Number of elements to be removed.
        * @param {...number} [itemN] - The element(s) to be add to the array. If no elements are given, splice() will only remove elements from the array.
        * @returns {module:la.BoolVector} Self. The selected elements are removed/replaced.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, true, false]);
        * // splice the vector by removing the last two elements and adding false, true
        * vec.splice(1, 2, false, true)// returns vector [true, false, true]
        */
     exports.BoolVector.prototype.splice = function (start, deleteCount, itemN) { return this; }
    /**
        * Adds elements to the beginning of the vector.
        * @param {...boolean} args - One or more elements to be added to the vector.
        * @returns {number} The new length of vector.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, true, false]);
        * // add two elements to the beggining of the vector
        * var len = vec.unshift(false, true); // returns 5
        */
     exports.BoolVector.prototype.unshift = function (args) { return 0; }
    /**
        * Appends a second vector to the first one.
        * @param {module:la.BoolVector} vec - The appended vector.
        * @returns {number} The new length property of the vectors.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create two new vectors
        * var vec = new la.BoolVector([true, true, false]);
        * var vec2 = new la.BoolVector([false, true]);
        * // append the two vectors
        * vec.pushV(vec2);
        */
     exports.BoolVector.prototype.pushV = function (vec) { return 0; }
    /**
        * Sums the elements in the vector.
        * @returns {number} The sum of all elements in the instance.
        * @example
        * // import la modules
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, true, false]);
        * // sum all the elements of the vector
        * var sum = vec.sum();
        */
     skip.exports.BoolVector.prototype.sum = function () { return BoolVectorDefaultVal; }
    /**
        * Gets the index of the maximal element.
        * @returns {number} Index of the maximal element in the vector.
        * // import la modules
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, true, false]);
        * // get the index of the maximum value
        * var idx = vec.getMaxIdx();
        *
        */
     skip.exports.BoolVector.prototype.getMaxIdx = function () { return 0; }
    /**
        * Vector sort comparator callback.
        * @callback boolVectorCompareCb
        * @param {boolean} arg1 - First argument.
        * @param {boolean} arg2 - Second argument.
        * @returns {(number | boolean)} If `boolVectorCompareCb(arg1, arg2)` is less than 0 or false, sort `arg1` to a lower index than `arg2`, i.e. `arg1` comes first.
        */
    /**
        * Sorts the vector (in place operation).
        * @param {(module:la~boolVectorCompareCb | boolean)} [arg] - Sort callback or a boolean ascend flag. Default is boolean and true.
        * @returns {module:la.BoolVector} Self.
        * &lt;br>1. Vector sorted in ascending order, if `arg` is boolean and true.
        * &lt;br>2. Vector sorted in descending order, if `arg` is boolean and false.
        * &lt;br>3. Vector sorted by using the comparator callback, if `arg` is a {@link module:la~boolVectorCompareCb}.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, false, false]);
        * // sort ascending
        * vec.sort(); // sorts to: [false, true, true]
        * // sort using callback
        * vec.sort(function(arg1, arg2) { return arg2; }); // sorts to: [false, true, true]
        */
     skip.exports.BoolVector.prototype.sort = function (bool) { return this; }
    /**
        * Sorts the vector and returns the sorted vector as well as the permutation.
        * @param {boolean} [asc = true] - Sort in ascending order flag.
        * @returns {Object} The object `BoolVectorSortResult` containing the properties:
        * &lt;br> `BoolVectorSortResult.vec` - The sorted vector,
        * &lt;br> `BoolVectorSortResult.perm` - Permutation vector, where `BoolVectorSortResult.vec[i] = instanceVector[BoolVectorSortResult.perm[i]]`.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, false, false]);
        * // sort ascending
        * var result = vec.sortPerm();
        * result.vec;  // [false, true, true]
        * result.perm; // permutation index vector
        */
     skip.exports.BoolVector.prototype.sortPerm = function (asc) { return {vec: Object.create(this), perm: Object.create(require('qminer').la.IntVector.prototype) }; }
    /**
        * Randomly reorders the elements of the vector (inplace).
        * @returns {module:la.BoolVector} Self. The elements are randomly reordered.
        * @example
        * // import la module
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, false, false]);
        * // shuffle the elements
        * vec.shuffle();
        */
     exports.BoolVector.prototype.shuffle = function () { return this; }
    /**
        * Deletes elements with sprecific index or more.
        * @param {boolean} idx - Index (zero based).
        * @returns {module:la.BoolVector} Self after truncating.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, true, false]);
        * // trunc all elements with index 1 or more
        * vec.trunc(1); // returns vector [true]
        */
     exports.BoolVector.prototype.trunc = function (idx) { return this; }
    /**
        * Creates a dense matrix A by multiplying two vectors x and y: `A = x * y^T`.
        * @param {module:la.BoolVector} vec - Second vector.
        * @returns {module:la.Matrix} Matrix obtained by the outer product of the instance and second vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.BoolVector([1, 2, 3]);
        * var y = new la.BoolVector([4, 5]);
        * // create the outer product of these vectors
        * var A = x.outer(y); // creates the dense matrix [[4, 5], [8, 10], [12, 15]]
        */
     skip.exports.BoolVector.prototype.outer = function (vec) { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Computes the inner product.
        * @param {module:la.Vector} vec - Other vector.
        * @returns {number} Inner product between the instance and the other vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 2, 3]);
        * var y = new la.Vector([4, 5, -1]);
        * // get the inner product of the two vectors
        * var prod = x.inner(y); // returns 11
        */
     skip.exports.Vector.prototype.inner = function(vec) { return 0; }
    /**
        * Returns the cosine between the two vectors.
        * @param {module:la.Vector} vec - Second vector.
        * @returns {number} The cosine between the two vectors.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 0]);
        * var y = new la.Vector([0, 1]);
        * // calculate the cosine between those two vectors
        * var num = x.cosine(y); // returns 0
        */
     skip.exports.Vector.prototype.cosine = function (vec) { return 0.0; }
    /**
        * Vector addition.
        * @param {module:la.Vector} vec - Second vector.
        * @returns {module:la.Vector} Sum of the instance and the second vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 2, 3]);
        * var y = new la.Vector([4, 5, -1]);
        * // sum the vectors
        * var z = x.plus(y);
        */
     skip.exports.Vector.prototype.plus = function (vec) { return Object.create(this); }
    /**
        * Vector substraction.
        * @param {module:la.Vector} vec - Second vector.
        * @returns {module:la.Vector} The difference of the instance and the other vector.
        * @example
        * var la = require('qminer').la;
        * // create two new vectors
        * var x = new la.Vector([1, 2, 3]);
        * var y = new la.Vector([4, 5, -1]);
        * // substract the vectors
        * var z = x.minus(y);
        */
     skip.exports.Vector.prototype.minus = function (vec) { return Object.create(this); }
    /**
        * Multiplies the vector with a scalar.
        * @param {number} val - Scalar.
        * @returns {module:la.Vector} Product of the vector and scalar.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var x = new la.Vector([4, 5, -1]);
        * // multiply the vector with the scalar 3
        * var y = x.multiply(3);
        */
     skip.exports.Vector.prototype.multiply = function (val) { return Object.create(this); }
    /**
        * Normalizes vector.
        * @returns {module:la.Vector} Self. The vector is normalized.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var x = new la.Vector([4, 5, -1]);
        * // normalize the vector
        * x.normalize();
        */
     skip.exports.Vector.prototype.normalize = function () { return this; }
    /**
        * Gives the length of vector. Type `number`.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var x = new la.BoolVector([true, true, false]);
        * // get the length of the vector
        * var len = x.length; // returns 3
        */
     exports.BoolVector.prototype.length = 0;
    /**
        * Returns the vector as string.
        * @returns {string} String representation.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, true, false]);
        * // create vector as string
        * vec.toString(); // returns 'true, true, false'
        */
     exports.BoolVector.prototype.toString = function () { return ''; }
    /**
        * Creates a dense diagonal matrix out of the vector.
        * @returns{module:la.Matrix} Diagonal matrix, where the (i, i)-th element is the i-th element of vector.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create a dense matrix with the diagonal equal to vec
        * var mat = vec.diag();
        */
     skip.exports.Vector.prototype.diag = function () { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Creates a sparse diagonal matrix out of the vector.
        * @returns {module:la.SparseMatrix} Diagonal matrix, where the (i, i)-th element is the i-th element of vector.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create a sparse matrix with the diagonal equal to vec
        * var mat = vec.spDiag();
        */
     skip.exports.BoolVector.prototype.spDiag = function () { return Object.create(require('qminer').la.SparseMatrix.prototype); }
    /**
        * Calculates the norm of the vector.
        * @returns {number} The norm of the vector.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // get the norm of the vector
        * var norm = vec.norm();
        */
     skip.exports.Vector.prototype.norm = function () { return 0.0; }
    /**
        * Creates the sparse vector representation of the vector.
        * @returns {module:la.SparseVector} The sparse vector representation.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create the sparse representation of the vector
        * var spVec = vec.sparse();
        */
     skip.exports.Vector.prototype.sparse = function () { return Object.create(require('qminer').la.SparseVector.prototype); }
    /**
        * Creates a matrix with a single column that is equal to the vector.
        * @returns {module:la.Matrix} The matrix with a single column that is equal to the instance.
        * @example
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.Vector([4, 5, -1]);
        * // create a matrix representation of the vector
        * var mat = vec.toMat();
        */
     skip.exports.Vector.prototype.toMat = function () { return Object.create(require('qminer').la.Matrix.prototype); }
    /**
        * Saves the vector as output stream (binary serialization).
        * @param {module:fs.FOut} fout - Output stream.
        * @returns {module:fs.FOut} The output stream `fout`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, true, false]);
        * // open write stream
        * var fout = fs.openWrite('vec.dat');
        * // save vector and close write stream
        * vec.save(fout).close();
        */
     exports.BoolVector.prototype.save = function (fout) {  return Object.create(require('qminer').fs.FOut.prototype); }
    /**
        * Loads the vector from input stream (binary deserialization).
        * @param {module:fs.FIn} fin - Input stream.
        * @returns {module:la.BoolVector} Self. The vector is filled using the input stream `fin`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create an empty vector
        * var vec = new la.BoolVector();
        * // open a read stream
        * var fin = fs.openRead('vec.dat');
        * // load the vector
        * vec.load(fin);
        */
     exports.BoolVector.prototype.load = function (fin) { return this; }
    /**
        * Saves the vector as output stream (ascii serialization).
        * @param {module:fs.FOut} fout - Output stream.
        * @returns {module:fs.FOut} The output stream `fout`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create a new vector
        * var vec = new la.BoolVector([true, true, false]);
        * // open write stream
        * var fout = fs.openWrite('vec.dat');
        * // save matrix and close write stream
        * vec.saveascii(fout).close();
        */
     exports.BoolVector.prototype.saveascii = function (fout) {  return Object.create(require('qminer').fs.FOut.prototype); }
    /**
        * Loads the vector from input stream (ascii deserialization).
        * @param {module:fs.FIn} fin - Input stream.
        * @returns {module:la.BoolVector} Self. The vector is filled using the input stream `fin`.
        * @example
        * // import fs module
        * var fs = require('qminer').fs;
        * var la = require('qminer').la;
        * // create an empty vector
        * var vec = new la.BoolVector();
        * // open a read stream
        * var fin = fs.openRead('vec.dat');
        * // load the matrix
        * vec.loadascii(fin);
        */
     exports.BoolVector.prototype.loadascii = function (fin) { return this; }