1 2 3
7 8 4
9 5 1

11 11.67 7,33

{-# LANGUAGE BangPatterns #-}
import Data.List

seqList [] = []
seqList a@(x:xs) = x `seq` seqList xs `seq` a
    
avgVec = avg . foldl' sum (0, [0,0..]) . map (map read . words) . lines
    where sum (!count, !a) b = (count+1, seqList $ zipWith (+) a b)
          avg (count, a) = map (/count) a

test n = avgVec $ unlines (take n $ repeat "1 2 3")

zipWith' f (a:as) (b:bs) = 
    let v = f a b 
    in v `seq` v : zipWith' f as bs

meanvec :: [[Double]] -> [Double]
meanvec xs =
    let (total, n) = foldl' (\(s, n) x -> (zipWith' (+) x s, n + 1)) (repeat 0, 0) xs 
    in map (/n) total

O>zipWith' f (a:as) (b:bs) = 
O>    let v = f a b 
O>    in v `seq` v : zipWith' f as bs

O>meanvec :: [[Double]] -> [Double]
O>meanvec xs =
O>    let (total, n) = foldl' (\(s, n) x -> (zipWith' (+) x s, n + 1)) (repeat 0, 0) xs 
O>    in map (/n) total
O>

meanvec :: Int -> [[Double]] -> [Double]
meanvec vlen xs =
    let
      init = replicate vlen 0
      (total, n) = go xs 0 init
    in map (/n) total
  where go [] n acc = (acc, n)
        go (x:xs) n acc = go xs (n+1) $ zipWith (+) x acc

genData rows cols = [ [r*1.0..r+cols-1] | r <- [1..rows]]
genFile rows cols file = writeFile file $ unlines [intercalate " " $ map show line | line <- genData rows cols]

-- читает двумерный массив из файла
readArray2 :: String -> IO [[Double]]
readArray2 file = do 
  str <- readFile file 
  return [map read $ split ' ' line | line <- lines str]

-- записывает массив в файл
writeArray :: String -> [Double] -> IO ()
writeArray file arr = writeFile file (intercalate " " $ map show arr)

-- обрабатывает inFile функцией fun и записывает результат в outFile
process inFile outFile fun = readArray2 inFile >>= return . fun >>= writeArray outFile

-- вычисляет среднее значение массива
avg :: [Double] -> Double
avg xs = sum xs / fromIntegral (length xs)

-- непосредственно обработка
fun :: [[Double]] -> [Double]
fun as = [avg line | line <- as]

main = do
  args <- getArgs
  let (inFile : outFile : _) = args
  process inFile outFile fun

{-# OPTIONS -ffi #-}
 
module QuickDouble (
  readDouble,
  showDouble
) where

import Data.ByteString.Lazy.Char8 (ByteString)
import qualified Data.ByteString.Char8      as B
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy.Char8 as L
import qualified Data.ByteString.Internal as BS
import Foreign
import Foreign.C.Types
import System.IO.Unsafe
 
------------------------------------------------------------------------
 
--
-- read a Double from a lazy ByteString
-- 'read' should be a pure operation, right??
--
readDouble :: ByteString -> Double
readDouble ls = unsafePerformIO $ B.useAsCString s $ \cstr ->
    realToFrac `fmap` c_strtod cstr nullPtr
  where
    s = B.concat . L.toChunks $ ls
 
foreign import ccall unsafe "static stdlib.h strtod" c_strtod
    :: Ptr CChar -> Ptr (Ptr CChar) -> IO CDouble
 
------------------------------------------------------------------------
--
-- show a Double into a lazy bytestring
--
 
showDouble :: Double -> ByteString
showDouble d = L.fromChunks . return . unsafePerformIO . BS.createAndTrim lim $  \p ->
    B.useAsCString fmt $ \cfmt -> do
        n <- c_printf_double (castPtr p) (fromIntegral lim) cfmt (realToFrac d)
        return (min lim (fromIntegral n)) -- snprintf might truncate
  where
    lim = 100 -- n.b.
    fmt = B.pack "%f"
 
foreign import ccall unsafe "static stdio.h snprintf" 
    c_printf_double :: Ptr CChar -> CSize -> Ptr CChar -> CDouble -> IO CInt

import qualified Data.ByteString.Lazy.Char8 as B
import QuickDouble -- наш новоиспеченный модуль

-- читает двуменрный массив из файла
readArray2 :: String -> IO [[Double]]
readArray2 file = do 
  str <- B.readFile file 
  return [map readDouble $ B.split ' ' line | line <- B.lines str]

-- записывает массив в файл
writeArray :: String -> [Double] -> IO ()
writeArray file arr = B.writeFile file (B.intercalate (B.pack " ") $ map showDouble arr)

fun1 = ...
fun2 = ...
fun3 = ...

process inFile outFile (fun1 . fun2 . fun3)

-- Функцию avg можно ускорить (процентов на 10)
avg xs = avg' xs 0 0
  where avg' [] sum count = sum / count
        avg' (p:ps) sum count = avg2' ps (sum+p) (count+1)
        
-- разделяет список на основе заданного разделителя
-- этой функции в библиотеке нет, зато есть в интернете. А для ByteString - в библиотеке есть
split _ [] = [ [] ]
split delim (c:cs)
   | c == delim = [] : rest
   | otherwise = (c : head rest) : tail rest
   where
       rest = split delim cs

O>Где-то я видел, что Haskell рекомендуют для быстрого написания как раз подобных утилит (всяких фильтров и пр.). Быстро получается, убедился, но производительность — хуже, чем на Бейсике.

B>-- обрабатывает inFile функцией fun и записывает результат в outFile
B>process inFile outFile fun = readArray2 inFile >>= return . fun >>= writeArray outFile
B>

-- работа с файлами
process (inFun,inFile) procFun (outFun,outFile) = inFun inFile >>= return . fun >>= outFun outFile

-- осталось создать
readArray = ... - читаем одномерный массив
readArray2 = ... - читаем двухмерный массив
readArray3 = ... - читаем трехмерный массив

writeArray = ... - то же для записи массивов
writeArray2 = ...
writeArray3 = ...

-- используем
proc3Dto1D = ...
process (readArray3, "3D.txt") proc3Dto1D (writeArray, "1D.txt")