Comments on: Solving Systems Of Linear Equations

By: Remco Niemeijer

Remco Niemeijer — Wed, 21 Jul 2010 20:26:03 +0000

My Haskell solution (see http://bonsaicode.wordpress.com/2010/07/21/programming-praxis-solving-systems-of-linear-equations/ for a version with comments):

import Control.Arrow
import Data.List
import qualified Data.List.Key as K

mult :: Num a => [[a]] -> [[a]] -> [[a]]
mult a b = [map (sum . zipWith (*) r) $ transpose b | r <- a]

elim :: Fractional a => [a] -> [a] -> [a]
elim ~(x:xs) ~(y:ys) = zipWith (-) ys $ map (y / x *) xs

identity :: Num a => [[a]] -> [[a]]
identity = zipWith (zipWith const) (iterate (0:) (1 : repeat 0))

lu :: Fractional a => [[a]] -> ([[a]], [[a]])
lu = unzip . map unzip . f where
    f []      = []
    f ~(x:xs) = zip (1 : repeat 0) x :
                zipWith (:) (map (\(y:_) -> (y / head x, 0)) xs)
                            (f $ map (elim x) xs)

perm :: (Fractional a, Ord a) => [[a]] -> [[a]]
perm m = f $ zip (identity m) m where
    f [] = []
    f xs = a : f (map (second $ elim b) $ delete (a,b) xs)
           where (a,b) = K.maximum (abs . head . snd) xs

lup :: (Fractional a, Ord a) => [[a]] -> ([[a]], [[a]], [[a]])
lup xs = (perm xs, l, u) where (l,u) = lu $ mult (perm xs) xs

lupsolve :: (Fractional a, Ord a) => [[a]] -> [a] -> [a]
lupsolve a b = f y u where
    (p,l,u) = lup a
    y = foldl (\x (l', pb') -> x ++ [pb' - sum (zipWith (*) x l')])
              [] (zip l (concat . mult p $ map return b))
    f _ [] = []
    f ~(y':ys) ~((r:rs):us) = (y' - sum (zipWith (*) rs z)) / r : z
        where z = (f ys $ map tail us)

By: Programming Praxis – Solving Systems Of Linear Equations « Bonsai Code

Wed, 21 Jul 2010 20:25:45 +0000

[...] Praxis – Solving Systems Of Linear Equations By Remco Niemeijer In yesterday’s Programming Praxis exercise our task is to implement some more matrix-related functions, [...]

By: programmingpraxis

programmingpraxis — Wed, 21 Jul 2010 13:18:14 +0000

Fixed four errors. I didn’t do that very well, did I?

By: Remco Niemeijer

Remco Niemeijer — Tue, 20 Jul 2010 22:45:15 +0000

Since I’m currently at a conference I don’t have as much time to devote to this as I’d like, but here’s my implementation of LU decomposition:

lu :: Fractional a => [[a]] -> ([[a]], [[a]])
lu = unzip . map unzip . elim where
    elim [] = []
    elim ~((r:rs):xs) = zip (1 : repeat 0) (r:rs) :
                        zipWith (:) (map (\(y:_) -> (y / r, 0)) xs)
                                    (elim $ map sub xs) where
        sub ~(y:ys) = zipWith (-) ys $ map (y / r *) rs

If I have some time before Friday I’ll see if I can work on the rest.

Also, you might want to fix the examples in the exercise, since they contain some errors (e.g. in the first example: 1×3 + 3×4 + 1×0 + 0×0 = 15, not 19). The versions used in the solution code are correct.