BlackBox : Math DSL beginning

Math DSL beginning

Warner Onstine — Fri, 23 Nov 2007 18:11:12 -0700

I decided to start working on this taking one of the examples I worked out for the book for math Sets (partially incomplete due to Groovy’s inability to directly override lessThan, lessThanEquals, greaterThan, greaterThanEquals) and to put into code some of the techniques I was learning in my Linear Algebra class.

So far I’ve implemented the following into my matrix math DSL:

Matrix/Row equality - allows you to test if two matrices or rows are equal (i.e. - contain the same ordered set of numbers)
Matrix addition/subtraction - You can add two matrices together if they are the same dimensions (2x2, 2x3, whatever, as long as the match in row and columns)
Matrix/Row scalar multiplication - You can multiply a scalar value against a row or matrix
Matrix multiplication - You can multiply two matrices together if the first matrix A’s (say 2x3) columns match B’s rows of the matrix you are multiplying against (say 3x2) which will produce a 2x2 matrix. If you did BxA then you would end up with a new matrix of 3x3
Matrix powers - If the matrix is square (say 3x3) you can multiply it by itself to get the power of the matrix
Left-shift operation - be able to dynamically create a Row or Matrix by adding new elements to the end

I still have a lot of work which is laid out on my Trac site for GroovyMath which leads me to my next conundrum.

When dealing with matrices you need to do a lot of Reduced Echelon Form (REF) or Row Reduced Echelon Form (RREF) this consists of taking one of two Elementary Row Operations (EROs) and applying it to a row to get a matrix in the form of a diagonal (all 1s down the upper-left to lower-right diagonal with 0s everywhere else) or getting it into an upper-diagonal form (0s below the diagonal and integers everywhere else). The two EROs that you can consist of a) row interchange, where you can exchange one row with another; and b) row addition, where you can add one row to another multiplying that row by a scalar. What I would like to be able to do is something like this:

def A = new Matrix(//rows go in here)
A.r1 + A.r2*2 //which will add 2 times the second row and add it to the first and replace it
A.r1 % A.r2 //which will exchange rows 1 and 2 with each other

Another thought I had was to do this in some kind of “rowOperations” closure:

def A = new Matrix(//rows go in here)
A.rowOperations {
    r1 + r2*2
    r1 % r2
}

Which definitely reads better than the first (and of course that’s all part of a DSL how well does it translate the native tongue into code). But the issue that I have with either of these approaches (maybe, still ironing out the second in my head) is that the properties r1 and r2 don’t exist. These property accessors will need to be intercepted. Ok, not a big deal. But if I choose to implement this in MatrixRow (i.e. - actually return the row itself) it doesn’t allow me to modify the originating matrix (A in this case) only change the row. For the addition problem I think I can get around it as it is executing in a closure, but the row interchange is an issue. The individual rows don’t know they’re a part of a matrix and I’m not sure that knowing it allows them to do anything.

Anyways, just wrestling with this concept right now as it is key to moving on to the more advanced functionality in my matrix math. Any suggestions are more than welcome. One new feature that I really like will be overriding the or operator to provide Augmented Matrices (another key part). Normally you define an augmented matrix in one of three ways:

A|0 - add a column of all zeros
A|b - add a vector as the augmented matrix
A|I - add an Identity matrix

The first two are used to solve the set of linear equations and a bunch of other things. The second is used to find the inverse of the matrix as you transform through EROs the matrix A so that it equals I (the identity matrix) and then the side that “I” was on now equals the inverse of A. I would say stop me if I’m boring you but it’s probably too late for that. I just wanted to point out how cool it was I can override the or operator to do something completely different that makes perfect sense in my given domain.

"Math DSL beginning" by Yann Richet

Sat, 24 Nov 2007 13:55:24 -0700

Hi,

I've started to work on similar issues (math dsl) a few weeks ago. You can get my work named groovylab on the front page of groovy project.

It also includes a simple plotter and is based on a pure java API to perform math calculations (to reduce performance issues).

Here is a little preview of what is already possible with groovylab:

Following access (i.e. set/get) are possible: x = M[1][2] x = M[-1][2] // where -1 stands for last row index x = M[1][-2] // where -2 stands for last column index x = M[-1][2] // where -1 stands for last row index x = M[-1][-2] // where -1 stands for last row index, -2 stands for last column index X = M[1..4][2..3] X = M[4..1][2..3] // thus reverting rows order X = M[1..-1][-2..3] X = diagonal(Matrix) // get diagonal of Matrix, alias to diag(Matrix) X = diagonal(Matrix, int order) // get order diagonal of Matrix, alias to diag(Matrix, int)

    M[1][2] = x         // set x value at first row, second column
    M[-1][2] = x        // set x value at last row, second column
    M[1..2][2..5] = [[1.1,1.2,1.3,1.4],[2.1,2.2,2.3,2.4]]
    M[2..1][2..5] = [[1.1,1.2,1.3,1.4],[2.1,2.2,2.3,2.4]]   // thus reverting rows order

Following operators are available:
    Matrix + Matrix
    Matrix + Number
    Matrix - Matrix
    Matrix - Number
    Matrix * Matrix
    Matrix * Number
    Matrix / Matrix
    Matrix / Number
    Matrix ** int"

Following static operations are available:
    sum(Matrix)
    prod(Matrix)
    cumsum(Matrix)
    cumprod(Matrix)
    inverse(Matrix)
    solve(Matrix A, Matrix b)   //returns X Matrix verifying A*X = b. if 
    rank(Matrix)
    trace(Matrix)
    det(Matrix)
    cond(Matrix)
    norm1(Matrix)
    norm2(Matrix)
    normF(Matrix)
    normInf(Matrix)

Following static Linear Algebra (from JAMA) are available:
    Cholesky decomposition:
        Cholesky_L(Matrix)
        Cholesky_SPD(Matrix)
    QR decomposition:
        QR_Q(Matrix)
        QR_H(Matrix)
        QR_R(Matrix)
    LU decomposition:
        LU_L(Matrix)
        LU_U(Matrix)
        LU_P(Matrix)
    Singular values decomposition:
        Singular_S(Matrix)
        Singular_U(Matrix)
        Singular_V(Matrix)
        Singular_values(Matrix)
    Eigenvalues decomposition:
        Eigen_D(Matrix)
        Eigen_V(Matrix)

Following static constructors are available:
    matrix(double[][])
    matrix(double[])    // one row Matrix constructor
    matrix(ArrayList)   // compatible with ArrayList of Numbers or ArrayList of ArrayList of Numbers

    identity(int n)         // identity Matrix of size n*n alias to id(int n)
    diagonal(int, double)   // diagonal Matrix of constant values, alias to diag(int, double)
    diagonal(double[])      // diagonal Matrix with given diagonal values, alias to diag(double[])
    one(int, int)           // constant Matrix of given size, filled with 1.0 values 
    fill(int, int, double)  // constant Matrix of given size, filled with given values 
    increment(int, int, double begin, double pitch) // Matrix of given size with row incrementing values from given beginning value wsith given pitch increment
    increment(int, int, double[] begin, double[] pitch) // Matrix of given size with row incrementing values from given beginning values wsith given pitchs increment

Following statistic sample constructors are available (random generator from RngPack):
    random(int, int)                                // independant random values (between 0.0 and 1.0) Matrix of given size, alias to rand(int, int)
    random(int, int, double min, double max)        // independant random values (between min and max) Matrix of given size, alias to rand(int, int, double min, double max)
    randomUniform(int m, int n, double min, double max)  
    randomDirac(int m, int n, double[] values, double[] prob)  
    randomNormal(int m, int n, double mu, double sigma)  
    randomChi2(int m, int n, int d)  
    randomLogNormal(int m, int n, double mu, double sigma)  
    randomExponential(int m, int n, double lambda)  
    randomTriangular(int m, int n, double min, double max)  
    randomTriangular(int m, int n, double min, double med, double max)  
    randomBeta(int m, int n, double a, double b)  
    randomCauchy(int m, int n, double mu, double sigma)  
    randomWeibull(int m, int n, double lambda, double c)  

Following static sort/find methods are available:
    sort(Matrix)
    sort(Matrix, int columnIndex)
    min(Matrix)
    max(Matrix)

Following static transformation methods are available:
    transpose(Matrix)   // alias to t(Matrix)
    resize(Matrix, int, int)
    rowsMatrix >> Matrix    // appends rowsMatrix to Matrix at last position (i.e. add last row)
    columnsMatrix >>> Matrix    // appends columnsMatrix to Matrix at last position (i.e. add last column)
    Matrix << rowsMatrix    // appends rowsMatrix to Matrix at first position (i.e. add first row)

Following static statistic sample methods are available:
    mean(Matrix)
    variance(Matrix)
    covariance(Matrix,Matrix)
    correlation(Matrix,Matrix)