Christopher Diebold

I have a simple domain class representing time. I want to calculate the elapsed time given start and end time and store it in the database.

import java.math.RoundingMode import java.time.LocalTime import java.time.format.DateTimeFormatter import java.time.temporal.ChronoUnit class TestTime { LocalTime startTime LocalTime endTime Double executionTime static constraints = { } static mapping = { // executionTime formula: elaspedTime(startTime, endTime) } double elaspedTime(LocalTime time1, LocalTime localTime2) { double expression = Math.abs(ChronoUnit.MINUTES.between(time1, localTime2)) / 60 //round decimal to 2 decimal places using a big decimal rounding BigDecimal bd = new BigDecimal(expression) return bd.setScale(2, RoundingMode.HALF_UP).doubleValue() }

my function works as I have unit tested it:
def 'test execution time calculation with the first time is larger than the second time'() { given: 'I have 2 different times to compare and the first time is larger than the second time' def time1 = LocalTime.of(12,00) def time2 = LocalTime.of(10,00); when: ' I calculate the difference in minutes' def minutes = elaspedTime(time1, time2) then: 'should be 2' 2.0.doubleValue() == minutes } def 'test execution time calculation with the second time is larger than the first time'() { given: 'I have 2 different times to compare and the first time is larger than the second time' def time1 = LocalTime.of(10,00); def time2 = LocalTime.of(12,00) when: ' I calculate the difference in minutes' def minutes = elaspedTime(time1, time2) then: 'should be 2' 2.0.doubleValue() == minutes } def 'test execution time calculation with units in minutes'() { given: 'I have 2 different times to compare and the first time is larger than the second time' def time1 = LocalTime.of(10,30); def time2 = LocalTime.of(12,00) when: ' I calculate the difference in minutes' double minutes = elaspedTime(time1, time2) then: 'should be 2.5' 1.5.doubleValue() == minutes }

I have tried to use the mapping closure that I found derived properties in the grails documentation.

What is the best approach? Is this something that should not be done in a domain class?

Jeff Verdegan wrote:Also, don't just print getRowSize(). You need to print out all of these

X.matrix.length X.matrix[i].length ZZ.matrix.length ZZ.matrix[i].length;

I can't say I much like variables named X and ZZ either.

ok i'll try it.

Jeff Verdegan wrote:That's an awful lot of code to read, so I'm not even going to try.

If you're getting an AIOOBE after 4 iterations on a length-8 array, then you're probably incrementing twice for each iteration. At the very least, you're incrementing more often of by a larger amount than you think.

So just before the line that's giving the exception, add a println() statement that shows you the length of the array and the index you're about to access. And then you may want to go add println()s everywhere you increment that index and print the before and after.

It is a lot. I understand. How about I just post the one method maybe 30 lines. Tell me if it looks right. Its just a double for loop.

private StrassenMatrix padZeros(StrassenMatrix ZZ) { int padSize = (int) Math.pow(2, Math.ceil(Math.log(ZZ.getRowSize() / Math.log(2)))); int nextPow = 2 * padSize; StrassenMatrix X = new StrassenMatrix(nextPow); //Debugging code================================================= System.out.println("Matrix Size before Setting it:"+ X.getRowSize()); //should be 8 which is correct. But loop only goes to 4 when debugging. //this loop should set the matrix with whatever values the parameter has and // the rest of the indices should be zero. //X.setMatrix(ZZ.matrix); for(int i = 0; i < X.getRowSize(); i++){ for(int j = 0; j <X.getRowSize();j++){ X.matrix[i][j] = ZZ.matrix[i][j]; //error here } } X.printMatrix(X); return X; }>

So I am trrying to implement Stressen's Algorithm for matrix multiplication and I have the weridest error when trying to pad my matrix with zeros. So in my padZeros method I am trying to create a bigger matrix to hold all the values of the next power of 2. SO a 5 x 5 matrix will do matrix multiplication on an 8 x 8 matrix. but when I go to set my matrix it will only iterate 4 times instead of 8 times which is werid because I print out the size of the matrix right before setting it as a debugging check. I dont know if this is maybe an inheritance thing or what. can someone please look at my code and help a fellow coder out? becasue I use inheritance I will post both classes but the error is in the StrassenMatrix.java and in the PadZero method. The comments explain the error. The error is on line 218 of the StrassenMatrix.java In case you dont know Strassens Algorithm here is a wiki link http://en.wikipedia.org/wiki/Strassen_algorithm

Matrix.java
public class Matrix { protected int rowSize; protected int columnSize; protected double[][] matrix; public Matrix() { rowSize = 1; columnSize = 1; matrix = new double[rowSize][columnSize]; } public Matrix(int n) { rowSize = n; columnSize = n; matrix = new double[rowSize][columnSize]; } public Matrix(int n, int m) { rowSize = n; columnSize = m; matrix = new double[rowSize][columnSize]; } /** * @return the rowSize */ public int getRowSize() { return rowSize; } /** * @param rowSize * the rowSize to set */ public void setRowSize(int rowSize) { this.rowSize = rowSize; } /** * @return the columnSize */ public int getColumnSize() { return columnSize; } /** * @param columnSize * the columnSize to set */ protected void setColumnSize(int columnSize) { this.columnSize = columnSize; } /** * @param d the matrix to set */ public void setMatrix(double[][] d) { this.matrix = d; } /** * @return the matrix */ protected double[][] getMatrix() { return matrix; } public Matrix multiply(Matrix b) { Matrix c = new Matrix(b.rowSize, b.columnSize); for (int i = 0; i < b.rowSize; i++) { for (int j = 0; j < b.columnSize; j++) { for (int k = 0; k < b.rowSize; k++) { c.matrix[i][j] = c.matrix[i][j] + matrix[i][k] * b.matrix[k][j]; } } } return c; } public Matrix add(Matrix b){ Matrix c = new Matrix(b.rowSize, b.columnSize); for (int i = 0; i < b.rowSize; i++) { for (int j = 0; j < b.columnSize; j++) { c.matrix[i][j] = c.matrix[i][j] + matrix[i][j] + b.matrix[i][j]; } } return c; } public Matrix subtract(Matrix b){ Matrix c = new Matrix(b.rowSize, b.columnSize); for (int i = 0; i < b.rowSize; i++) { for (int j = 0; j < b.columnSize; j++) { c.matrix[i][j] = c.matrix[i][j] + matrix[i][j] - b.matrix[i][j]; } } return c; } public void printMatrix(Matrix d){ double matrix [][] = d.getMatrix(); for(int i = 0; i < rowSize; i ++){ for(int j = 0; j < columnSize; j++){ System.out.printf("%8.2f ", matrix[i][j]); } System.out.println(); } } }
StrassenMatrix.java
public class StrassenMatrix extends Matrix { /* * Constructors are the same as in the super class. Since Constructors are * not inherited they are recreated calling the super class's constructors */ public StrassenMatrix() { super(); } public StrassenMatrix(int n) { super(n); } public StrassenMatrix(int n, int m) { super(n, m); } public StrassenMatrix strassenMultiply(StrassenMatrix b) throws InputMismatchException { StrassenMatrix result = new StrassenMatrix(b.rowSize, b.columnSize); // defensive programming checks: // check to make sure the matrices are square if (this.rowSize != b.rowSize || this.columnSize != b.columnSize || this.rowSize != b.columnSize) { throw new InputMismatchException( "Matries must be the same size and must be square"); } if (this.rowSize == 1) { result.matrix[0][0] = this.matrix[0][0] * b.matrix[0][0]; return result; } else { StrassenMatrix A; StrassenMatrix B; StrassenMatrix C; StrassenMatrix D; StrassenMatrix E; StrassenMatrix F; StrassenMatrix G; StrassenMatrix H; //check pow of 2 and divide into submatrices // each matrix will be split in 4. A: a,c,d,z and B: e,f,g,h // submatrices respectively if(checkPow(this.getRowSize())){ //if true then no padding is needed. A = new StrassenMatrix(this.getRowSize()); B = new StrassenMatrix(this.getRowSize()); C = new StrassenMatrix(this.getRowSize()); D = new StrassenMatrix(this.getRowSize()); E = new StrassenMatrix(b.getRowSize()); F = new StrassenMatrix(b.getRowSize()); G = new StrassenMatrix(b.getRowSize()); H = new StrassenMatrix(b.getRowSize()); //Create and initialize Matrix A partitions StrassenMatrix a = new StrassenMatrix(this.getRowSize() / 2); StrassenMatrix c = new StrassenMatrix(this.getRowSize() / 2); StrassenMatrix d = new StrassenMatrix(this.getRowSize() / 2); StrassenMatrix z = new StrassenMatrix(this.getRowSize() / 2); //Create and initialize Matrix B partitions StrassenMatrix e = new StrassenMatrix(b.getRowSize() / 2); StrassenMatrix f = new StrassenMatrix(b.getRowSize() / 2); StrassenMatrix g = new StrassenMatrix(b.getRowSize() / 2); StrassenMatrix h = new StrassenMatrix(b.getRowSize() / 2); //Set Matrix A partitions a.setMatrix(this.matrix); c.setMatrix(this.matrix); d.setMatrix(this.matrix); z.setMatrix(this.matrix); //Set Matrix B partitions e.setMatrix(b.matrix); f.setMatrix(b.matrix); g.setMatrix(b.matrix); h.setMatrix(b.matrix); //partition Matrix A A = a.partition(this, this.getRowSize(), 0, 0); B = c.partition(this, this.getRowSize(), 0, 1); C = d.partition(this, this.getRowSize(), 1, 0); D = z.partition(this, this.getRowSize(), 1, 1); //partition matrix B E = e.partition(b, b.getRowSize(), 0, 0); F = f.partition(b, b.getRowSize(), 0, 1); G = g.partition(b, b.getRowSize(), 1, 0); H = h.partition(b, b.getRowSize(), 1, 1); } else{ //we must pad with 0s before partitioning StrassenMatrix paddedMatrixA = padZeros(this); StrassenMatrix paddedMatrixB = padZeros(b); paddedMatrixA.printMatrix(paddedMatrixA); A = new StrassenMatrix(paddedMatrixA.getRowSize()); B = new StrassenMatrix(paddedMatrixA.getRowSize()); C = new StrassenMatrix(paddedMatrixA.getRowSize()); D = new StrassenMatrix(paddedMatrixA.getRowSize()); E = new StrassenMatrix(paddedMatrixB.getRowSize()); F = new StrassenMatrix(paddedMatrixB.getRowSize()); G = new StrassenMatrix(paddedMatrixB.getRowSize()); H = new StrassenMatrix(paddedMatrixB.getRowSize()); StrassenMatrix a = new StrassenMatrix(paddedMatrixA.getRowSize() / 2); StrassenMatrix c = new StrassenMatrix(paddedMatrixA.getRowSize() / 2); StrassenMatrix d = new StrassenMatrix(paddedMatrixA.getRowSize() / 2); StrassenMatrix z = new StrassenMatrix(paddedMatrixA.getRowSize() / 2); StrassenMatrix e = new StrassenMatrix(paddedMatrixB.getRowSize() / 2); StrassenMatrix f = new StrassenMatrix(paddedMatrixB.getRowSize() / 2); StrassenMatrix g = new StrassenMatrix(paddedMatrixB.getRowSize() / 2); StrassenMatrix h = new StrassenMatrix(paddedMatrixB.getRowSize() / 2); //Set Matrix A partitions a.setMatrix(paddedMatrixA.matrix); c.setMatrix(paddedMatrixA.matrix); d.setMatrix(paddedMatrixA.matrix); z.setMatrix(paddedMatrixA.matrix); //Set Matrix B partitions e.setMatrix(paddedMatrixB.matrix); f.setMatrix(paddedMatrixB.matrix); g.setMatrix(paddedMatrixB.matrix); h.setMatrix(paddedMatrixB.matrix); //partition matrix A A = a.partition(paddedMatrixA, paddedMatrixA.getRowSize(), 0, 0); B = c.partition(paddedMatrixA, paddedMatrixA.getRowSize(), 0, 1); C = d.partition(paddedMatrixA, paddedMatrixA.getRowSize(), 1, 0); D = z.partition(paddedMatrixA, paddedMatrixA.getRowSize(), 1, 1); // partition of matrix B E = e.partition(paddedMatrixB, paddedMatrixB.getRowSize(), 0, 0); F = f.partition(paddedMatrixB, paddedMatrixB.getRowSize(), 0, 1); G = g.partition(paddedMatrixB, paddedMatrixB.getRowSize(), 1, 0); H = h.partition(paddedMatrixB, paddedMatrixB.getRowSize(), 1, 1); } //problem here.....possibly // s1 = (B-D) * (G + H) Matrix s1 = B.subtract(D).multiply(G.add(H)); // s2 = (A+D)*(E+H) Matrix s2 = A.add(D).multiply(E.add(H)); // s3 = (A-C)*(E+F) Matrix s3 = C.subtract(A).multiply(E.add(F)); // s4 = (A+B)*H Matrix s4 = A.add(B).multiply(H); // s5 = A*(F-H) Matrix s5 = A.multiply(F.subtract(H)); // s6 = D*(G-E) Matrix s6 = D.multiply(G.subtract(E)); // s7 = (C+D)*E Matrix s7 = C.add(D).multiply(E); //remove padding here // now we need to do some operations to create the 4 partitions to // be combined // following the slide // c1 = (s1+s2-s4+s6) Matrix c1 = s1.add(s2).subtract(s4).add(s6); // c2 = s4 + s5 Matrix c2 = s4.add(s5); // c3 = s6 + s7 Matrix c3 = s6.add(s7); // c4 = s2 + s3 + s5 - s7 Matrix c4 = s2.add(s3).add(s5).subtract(s7); // Combine the partitions and get a result result = result.Combine(this, c1, c2, c3, c4); return result; } } private StrassenMatrix partition(StrassenMatrix x, int size, int msb, int lsb) { StrassenMatrix C = new StrassenMatrix(x.rowSize /2); //StrassenMatrix Sa = new StrassenMatrix(x.getRowSize()); C.setMatrix(x.matrix); for (int i = 0; i < x.getRowSize() / 2; i++) { for (int j = 0; j < x.getColumnSize() / 2; j++) { C.matrix[i][j] = x.matrix[(x.rowSize / 2 * msb) + i][(x.columnSize / 2 * lsb) + j]; } } return C; } /** * This function will calculate the next power of 2 to raise the matrix to that power and * will return a new StrassenMatrix padded with 0s. * @param ZZ */ private StrassenMatrix padZeros(StrassenMatrix ZZ) { int padSize = (int) Math.pow(2, Math.ceil(Math.log(ZZ.getRowSize() / Math.log(2)))); int nextPow = 2 * padSize; StrassenMatrix X = new StrassenMatrix(nextPow); //Debugging code================================================= System.out.println("Matrix Size before Setting it:"+ X.getRowSize()); //should be 8 which is correct. But loop only goes to 4 when debugging. //this loop should set the matrix with whatever values the parameter has and // the rest of the indices should be zero. //X.setMatrix(ZZ.matrix); for(int i = 0; i < X.getRowSize(); i++){ for(int j = 0; j <X.getRowSize();j++){ X.matrix[i][j] = ZZ.matrix[i][j]; //error here } } X.printMatrix(X); return X; } private StrassenMatrix removePadding(StrassenMatrix A){ StrassenMatrix result = new StrassenMatrix(this.getRowSize()); result.setMatrix(A.matrix); return result; } /** * This function will return true if the num is a power of 2 * examples: 2,4,8,16,32... * @param num - the size of the matrix * @return isPowerOfTwo */ private boolean checkPow(int num) { return ((num!=0) && (num&(num-1))==0); } /** * This function will combine the partitions of a matrix into a single matrix that is * returned. * @param x - the StrassenMatrix used to get the original size of a matrix * @param c1 - a matrix partition * @param c2 - a matrix partition * @param c3 - a matrix partition * @param c4 - a matrix partition * @return - a StrassenMatrix which is the result */ private StrassenMatrix Combine(StrassenMatrix x, Matrix c1, Matrix c2, Matrix c3, Matrix c4) { StrassenMatrix result = new StrassenMatrix(x.rowSize); for (int i = 0; i < x.getRowSize() / 2; i++) { for (int j = 0; j < x.getColumnSize() / 2; j++) { result.matrix[i][j] = c1.matrix[i][j]; result.matrix[i][j + result.rowSize / 2] = c2.matrix[i][j]; result.matrix[i + result.getRowSize() / 2][j] = c3.matrix[i][j]; result.matrix[i + result.getRowSize() / 2][j + result.getRowSize() / 2] = c4.matrix[i][j]; } } return result; } public static void main(String[] args) { StrassenMatrix A = new StrassenMatrix(5); StrassenMatrix B = new StrassenMatrix(5); double[][] a = new double[A.rowSize][B.columnSize]; double[][] b = new double[A.rowSize][B.columnSize]; for (int i = 0; i < a.length; i++) { for (int j = 0; j < b.length; j++) { // java.lang.Math.Random() * 25; a[i][j] = 5; b[i][j] = 5; } } A.setMatrix(a); System.out.println("Matrix A is:"); A.printMatrix(A); B.setMatrix(b); System.out.println("Matrix B is:"); B.printMatrix(B); try { StrassenMatrix C = A.strassenMultiply(B); System.out.println("AB ="); C.printMatrix(C); } catch (InputMismatchException e) { System.out.println("Matrices are not square and not the same size"); } } }