mtrx v0.1.6

default class Mtrx is extends Array.

Installation

    $ npm install mtrx

Properties

• Mtrx.rows
• Mtrx.cols
• Mtrx.rank
• Mtrx.det

Methods

• Mtrx.zeros()
• Mtrx.ones()
• Mtrx.eye()
• Mtrx.rand()
• Mtrx.like()
• Mtrx.diag()
• Mtrx.clone()
• Mtrx.isMtrx()
• Mtrx.isMtrxLike()
• Mtrx.isDiag()
• Mtrx.isSingular()
• Mtrx.isSameShape()
• Mtrx.equal()
• Mtrx.equalAll()
• Mtrx.equalAny()
• Mtrx.prototype.get()
• Mtrx.prototype.set()
• Mtrx.prototype.changeRows()
• Mtrx.prototype.changeCols()
• Mtrx.prototype.resetLike()
• Mtrx.prototype.cof()
• Mtrx.prototype.T()
• Mtrx.prototype.compan()
• Mtrx.prototype.inv()
• Mtrx.prototype.LUP()
• Mtrx.prototype.mapMtrx()
• Mtrx.prototype.everyMtrx()
• Mtrx.prototype.someMtrx()
• Mtrx.prototype.reduceMtrx()
• Mtrx.prototype.rightMul()
• Mtrx.prototype.leftMul()
• Mtrx.prototype.rightDiv()
• Mtrx.prototype.leftDiv()

Usage

    const Mtrx = require('mtrx');

creation

It is really easy to create a matrix object what you want.

    // No arguments, create a 1x1 random(0 ~ 1) matrix
    new Mtrx()
    // -> Mtrx [ [ 0.7173410249746024 ] ]
    
    new Mtrx(2)
    // -> Mtrx [
    //  [ 0.9028933497295337, 0.18980748816858917 ],
    //  [ 0.10859200880292263, 0.560035422729191 ] ]
    
    new Mtrx(2, 3)
    // -> Mtrx [
    //  [ 0.6974184450003136, 0.6402339494410889, 0.4553998131618524 ],
    //  [ 0.38759912033793165, 0.8904429716538196, 0.7449091649551736 ] ]
    
    new Mtrx(3, 4, 9)
    // -> Mtrx [ [ 9, 9, 9, 9 ], [ 9, 9, 9, 9 ], [ 9, 9, 9, 9 ] ]
    
    // Get numbers array, create a diag matrix
    new Mtrx([2, 4, 6])
    // -> Mtrx [ [ 2, 0, 0 ], [ 0, 4, 0 ], [ 0, 0, 6 ] ]
    
    // Get a 2-order numbers array, create a matrix like the array
    new Mtrx([[1, 2, 3], [4, 5, 6]])
    // -> Mtrx [ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
    
    // Get a function expression, create a matrix by the expression
    new Mtrx(2, 3, (i, j) => i + j)
    // -> Mtrx [ [ 0, 1, 2 ], [ 1, 2, 3 ] ]

operation

Mtrx object is a Array-like object. So, you can operat it just like to operat a 2-order Array.

    const m = new Mtrx(2, 3, 0)
    // -> Mtrx [ [ 0, 0, 0 ], [ 0, 0, 0 ] ]
    
    m[1][1]     // or     m.get(1, 1)
    // -> 0
    
    m[0][1] = 1     //or     m.set(0, 1, 1)
    // -> Mtrx [ [ 0, 1, 0 ], [ 0, 0, 0 ] ]

properties

    const m = new Mtrx(2, 3, (i, j) => (i === j) ? 1 : 0)
    // -> Mtrx [ [ 1, 0, 0 ], [ 0, 1, 0 ] ]
    const n = new Mtrx([
      [1, 2, 0],
      [3, 4, 4],
      [5, 6, 3]
    ])
    
    m.rows  // -> 2
    m.cols  // -> 3
    
    n.det  // -> 10
    m.det  // -> NaN
    // If the Mtrx object's rows and cols was not equal, det would be NaN
    
    m.rank  // -> 2     
    m[0][0] = 0
    // -> Mtrx [ [ 0, 0, 0 ], [ 0, 1, 0 ] ]
    m.rank  // -> 1

static function

all the static functions is Immutable.

    Mtrx.zeros(3, 3)
    // -> Mtrx [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ]
    
    Mtrx.ones(3, 4)
    // -> Mtrx [ [ 1, 1, 1, 1 ], [ 1, 1, 1, 1 ], [ 1, 1, 1, 1 ] ]
    
    Mtrx.eye(3)
    // -> Mtrx [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1] ]
    
    Mtrx.diag([2, 4, 6])
    // -> Mtrx [ [ 2, 0, 0 ], [ 0, 4, 0 ], [ 0, 0, 6 ] ]

    const n = [[0, 1, 2], [1, 2, 3]]
    const m = new Mtrx(n)
    // -> Mtrx [ [ 0, 1, 2 ], [ 1, 2, 3 ] ]
    
    Mtrx.isMtrx(n)     // -> false
    Mtrx.isMtrx(m)     // -> true
    
    Mtrx.isMtrxLike(n)     // -> true
    Mtrx.isDiag(m)     // -> false
    Mtrx.isSameShape(m, n)     // -> true

    const m = new Mtrx([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
    const n = new Mtrx([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    
    Mtrx.add(m, n)
    // -> Mtrx [ [ 2, 2, 3 ], [ 4, 6, 6 ], [ 7, 8, 10 ] ]
    
    Mtrx.mul(m, 3)
    // -> Mtrx [ [ 3, 0, 0 ], [ 0, 3, 0 ], [ 0, 0, 3 ] ]
    
    Mtrx.mul(m, n)
    // -> Mtrx [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ]
    
    Mtrx.div(n, m)
    // -> Mtrx [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ]

methods

Following functions will always return a new Mtrx object.

    const m = new Mtrx([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
    const n = new Mtrx([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    
    m.add(n)   // like Mtrx.add(m, n)
    
    m.leftMul(n)   // like Mtrx.mul(m, n)
    m.rightMul(n)   // like Mtrx.mul(n, m)
    
    n.cof(1, 1)
    // -> Mtrx [ [ 1, 3 ], [ 7, 9 ] ]
    
    // a powerful function
    m.mapMtrx((i, j, n) => i + j + n);
    // -> Mtrx [ [ 1, 1, 2 ], [ 1, 3, 3 ], [ 2, 3, 5 ] ]

    const m = new Mtrx(2, 3, (i, j) => (i === j) ? 1 : 0)
    // -> Mtrx [ [ 1, 0, 0 ], [ 0, 1, 0 ] ]
    const n = new Mtrx([
      [1, 2, 0],
      [3, 4, 4],
      [5, 6, 3]
    ])
    
    n.T()
    
    n.LUP()
    // -> { L: Mtrx [ [ 1, 0, 0 ], [ 0.2, 1, 0 ], [ 0.6, 0.5, 1 ] ],
    //      U: Mtrx [ [ 5, 6, 3 ], [ 0, 0.8, -0.6 ], [ 0, 0, 2.5 ] ],
    //      P: Mtrx [ [ 0, 0, 1 ], [ 1, 0, 0 ], [ 0, 1, 0 ] ] }
    n.LUP().L
    // -> Mtrx [ [ 1, 0, 0 ], [ 0.2, 1, 0 ], [ 0.6, 0.5, 1 ] ]
    
    n.inv()
    // -> Mtrx [ [ -1.2, -0.6, 0.8 ], [ 1.1, 0.3, -0.4 ], [ -0.2, 0.4, -0.2 ] ]
    
    // If there is no corresponding matrix, you would get a Error.
    m.LUP()
    m.inv()
    m.compan()
    // -> Error: ...