Dfyjkt

I want to learn TDD for working in Linear Algebra (or basically with matrices) in scientific programming(quantum chemistry). However since intermediates are not known and the only thing sometimes known are the end results I dont know how to do it.

Can you show me how you would do TDD in the above example?

for i,j = start1:end1, k,l = start2:end2
 A[i,j] = B[i,k] * C[k,l] * D[l,j]
end

with A being the new Matrix calculated in the function.

with B C D being predefined Matrices.

with start1, start2, end1, end2 being predefined integers.

In a usual program I have around 20 of these blocks. So I think I dont know anything about the new A.

Most bugs I have are simple typing errors like doing

B[k,i]

instead of the above.

The only debugging scheme I am able to do if the end result is wrong is to write everything twice and then checking both A and hope I have not done the same typing error twice.

THX for your help

Can you show me how you would do TDD in the above example?

The good news is that you are fundamentally dealing with a function.

A = function(B,C,D,start1,end1,start2,end2)

There are two general approaches that I see to introducing tests

1) start with simple problems - one by one matrices, unit matrices; each time you work out what the answer should be, and check that the correct answer is produced by the function

2) start with simple validations - you might start by ensuring that the answer has the right number of rows and columns, that doubling one of the inputs doubles the output, and so on. Nat Pryce's demonstration of the Diamond Kata should give you a sense for how this might work.

A technique I've used to test matrix multiplication routines is to use matrices with just one 1, all else being zero.
Let E(i,j) be the matrix

E(i,j)[k,l] = delta(i,k)*delta(j,l)

(ie has a 1 at [i,j] and zeroes elsewhere)
A bit of algebra shows that

E(i,j)*E(i',j') = delta(j,i')*E(i,j')

The test is to check that the multiplication routine gets the write answer for all pow(n,4) tuples i,j,i',j' with nxn matrices.

A Friend of mine showed me how to test these Functions.

It is done by mocking the matrices.

You can imagine

B[i,k] 

as

function B(i,k): 
return B[i,k] 

Now you can test these by creating a list which tracks the inputs.

This gives the following function.

function B(i,k):
list.append(i,k)
return B[i,k]

This list can then be tested on which index is the faster one. This depends on column or row first and how you define your loop but you will either get something like:

1 1
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3

or

1 1
2 1
3 1
1 2
2 2
3 2
1 3
2 3
3 3

Now B[i,k] and B[k,i] in the function of the question will produce different lists therefor you can detect the error and so you can test them.