buffering calculations in haskell array initialization - haskell

Question

Right now i am porting my mathematical solution from c# to Haskell, learning Haskell in process. I have following code for Thompson algorithm:
xi[N] = a[N] / c[N];
eta[N] = f[N] / c[N];
for (int i = N - 1; i > 0; i--)
{
var cbxip = (c[i] - b[i] * xi[i + 1]);
xi[i] = a[i] / cbxip;
eta[i] = (f[i] + b[i] * eta[i + 1]) / cbxip;
}
{
int i = 0;
var cbxip = (c[i] - b[i] * xi[i + 1]);
eta[i] = (f[i] + b[i] * eta[i + 1]) / cbxip;
}
How do I do it in Haskell?
I found info on array initialization, but I have several problems with it.
Say, I wrote the following code:
xi = [a[i] / (c[i] - b[i] * xi[i + 1]) | i <- 1..N-1] ++ [a[N] / c[N]]
etha = [(f[i] + b[i] * etha[i + 1] / (c[i] - b[i] * xi[i + 1]) | i <- 0..N-1] ++ [f[N] / c[N]]
The problems are following:
How do I specify I have to initialize array starting right? Do I even need to do so, or Haskell will grasp it by itself? If latter, how can it do that? isn't it is just a blackbox like[f(i)|i<-[a..b]] for a compiler?
(most problematic) For all i in [1..N-1] the part (c[i] - b[i] * xi[i + 1]) is going to be evaluated twice. How can I fix this? Prior mapping it to some other array will cost memory and is impossible as I don't have xi array yet.
I thought of something like simultaneous mapping, but I am confused with how to apply it to array initializing.

Answer 1

I would probably avoid using list comprehensions until you become really familiar with solving problems through recursion. Haskell is very different to C# in that you don't have "arrays" as such, which can be randomly accessed and inserted - you can't pre-allocate this space up front, because allocation is a side effect. Instead, consider everything to be linked lists, and to use recursion to iterate through them.
If we start with a top-down approach, we have a bunch of lists of numbers, and we need a function to iterate through them. If we passed these separately we would end up with a function signature like [n] -> [n] -> [n] -> [n] -> [n] -> ... This is probably not a good idea considering they all seem to be the same size, N. Instead, we can use a tuple (or pair of tuples) to contain them, eg.
thompson :: Num n => [(n, n, n, n, n, n)] -> [(n, n)]
thompson [] = [] -- pattern to terminate recursion for empty lists
-- these variables are equivalent to your a[i], etc in C#
thompson ((a, b, c, f, xi, eta):_) = ?
If we are duplicating your C# exactly, we probably want patterns for the case of 2 elements in the list, since it seems that each iteration needs to access the current and next elements. For 2 or more elements.
-- handle final 2 elements
thompson ((a, _, c, f, xi, eta):[]) = ((a / c), (f / c))
thompson ((a0, b0, c0, f0, xi0, eta0):(_,_,_,_,xi1,eta1):[]) = ?
-- handle the regular case.
thompson ((a0, b0, c0, f0, xi0, eta0):(a1,b1,c1,f1,xi1,eta1):tail) = ?
Once you have the overall iterative structure, it should become more obvious how to implement what's in the loop. The loop is basically a function which takes one of these tuples, plus a tuple for the next xi/eta and does some calculation, returning a new tuple for xi/eta (or in the final case, just eta). The a,b,c,f appear to not change.
doCalc1 :: Num n => (n, n, n, n, n, n) -> (n, n) -> (n, n)
doCalc1 (a, b, c, f, xi0, eta0) (xi1, eta1) = (a / cbxip, f + b * eta1 / cbxip)
where cbxip = c - b * xi1
doCalc2 :: Num n => Num n => (n, n, n, n, n, n) -> (n, n) -> n
doCalc2 (a, b, c, f, xi0, eta0) (xi1, eta1) = f + b * eta1 / cbxip
where cbxip = c - b * xi1
Now we just need to update thompson to call doCalc1/doCalc2, and recursively call itself with the tail.
thompson (head:next#(_,_,_,_,xi,eta):[])
= (xi, doCalc2 head (xi, eta)) : thompson [next]
thompson (head:next#(_,_,_,_,xi,eta):tail)
= doCalc1 head (xi, eta) : thompson (next:tail)