1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
-----------------------------------------------------------------------------
-- |
-- Module : Data.Packed.Vector
-- Copyright : (c) Alberto Ruiz 2007
-- License : GPL-style
--
-- Maintainer : Alberto Ruiz <aruiz@um.es>
-- Stability : provisional
-- Portability : portable
--
-- 1D arrays suitable for numeric computations using external libraries.
--
-----------------------------------------------------------------------------
module Data.Packed.Vector (
Vector,
fromList, (|>), toList, buildVector,
dim, (@>),
subVector, takesV, join,
constant, linspace,
vecdisp,
vectorFMax, vectorFMin, vectorFMaxIndex, vectorFMinIndex,
vectorMax, vectorMin, vectorMaxIndex, vectorMinIndex,
mapVector, zipVector,
fscanfVector, fprintfVector, freadVector, fwriteVector,
foldLoop, foldVector, foldVectorG
) where
import Data.Packed.Internal
import Numeric.GSL.Vector
-- import Data.Packed.ST
import Data.Binary
import Foreign.Storable
import Control.Monad(replicateM)
-------------------------------------------------------------------
-- a 64K cache, with a Double taking 13 bytes in Bytestring,
-- implies a chunk size of 5041
chunk :: Int
chunk = 5000
chunks :: Int -> [Int]
chunks d = let c = d `div` chunk
in ((d-c*chunk):(replicate c chunk))
putVector v = do
let d = dim v
mapM_ (\i -> put $ v @> i) [0..(d-1)]
getVector d = do
xs <- replicateM d get
return $! fromList xs
instance (Binary a, Storable a) => Binary (Vector a) where
put v = do
let d = dim v
put d
mapM_ putVector $! takesV (chunks d) v
get = do
d <- get
vs <- mapM getVector $ chunks d
return $! join vs
-------------------------------------------------------------------
{- | Creates a real vector containing a range of values:
@\> linspace 5 (-3,7)
5 |> [-3.0,-0.5,2.0,4.5,7.0]@
Logarithmic spacing can be defined as follows:
@logspace n (a,b) = 10 ** linspace n (a,b)@
-}
linspace :: Int -> (Double, Double) -> Vector Double
linspace n (a,b) = add a $ scale s $ fromList [0 .. fromIntegral n-1]
where scale = vectorMapValR Scale
add = vectorMapValR AddConstant
s = (b-a)/fromIntegral (n-1)
vectorFMax :: Vector Float -> Float
vectorFMax = toScalarF Max
vectorFMin :: Vector Float -> Float
vectorFMin = toScalarF Min
vectorFMaxIndex :: Vector Float -> Int
vectorFMaxIndex = round . toScalarF MaxIdx
vectorFMinIndex :: Vector Float -> Int
vectorFMinIndex = round . toScalarF MinIdx
vectorMax :: Vector Double -> Double
vectorMax = toScalarR Max
vectorMin :: Vector Double -> Double
vectorMin = toScalarR Min
vectorMaxIndex :: Vector Double -> Int
vectorMaxIndex = round . toScalarR MaxIdx
vectorMinIndex :: Vector Double -> Int
vectorMinIndex = round . toScalarR MinIdx
{- | creates a vector with a given number of equal components:
@> constant 2 7
7 |> [2.0,2.0,2.0,2.0,2.0,2.0,2.0]@
-}
constant :: Element a => a -> Int -> Vector a
-- constant x n = runSTVector (newVector x n)
constant = constantD -- about 2x faster
{- | creates a Vector of the specified length using the supplied function to
to map the index to the value at that index.
@> buildVector 4 fromIntegral
4 |> [0.0,1.0,2.0,3.0]@
-}
buildVector :: Element a => Int -> (Int -> a) -> Vector a
buildVector len f =
fromList $ map f [0 .. (len - 1)]
{- | Show a vector using a function for showing matrices.
@disp = putStr . vecdisp ('dispf' 2)
\> disp ('linspace' 10 (0,1))
10 |> 0.00 0.11 0.22 0.33 0.44 0.56 0.67 0.78 0.89 1.00
@
-}
vecdisp :: (Element t) => (Matrix t -> String) -> Vector t -> String
vecdisp f v
= ((show (dim v) ++ " |> ") ++) . (++"\n")
. unwords . lines . tail . dropWhile (not . (`elem` " \n"))
. f . trans . reshape 1
$ v
|
