blob: 1e5877df71d43b4fa4b975380f6eb9410492bcbf (
plain)
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
-----------------------------------------------------------------------------
-- |
-- Module : Numeric.Vector
-- Copyright : (c) Alberto Ruiz 2011
-- License : BSD3
--
-- Maintainer : Alberto Ruiz
-- Stability : provisional
--
-- Provides instances of standard classes 'Show', 'Read', 'Eq',
-- 'Num', 'Fractional', and 'Floating' for 'Vector'.
--
-----------------------------------------------------------------------------
module Numeric.Vector () where
import Internal.Vectorized
import Internal.Vector
import Internal.Numeric
import Internal.Conversion
import Foreign.Storable(Storable)
-------------------------------------------------------------------
adaptScalar :: (Foreign.Storable.Storable t1, Foreign.Storable.Storable t2)
=> (t1 -> Vector t2 -> t)
-> (Vector t1 -> Vector t2 -> t)
-> (Vector t1 -> t2 -> t)
-> Vector t1
-> Vector t2
-> t
adaptScalar f1 f2 f3 x y
| dim x == 1 = f1 (x@>0) y
| dim y == 1 = f3 x (y@>0)
| otherwise = f2 x y
------------------------------------------------------------------
instance Num (Vector I) where
(+) = adaptScalar addConstant add (flip addConstant)
negate = scale (-1)
(*) = adaptScalar scale mul (flip scale)
signum = vectorMapI Sign
abs = vectorMapI Abs
fromInteger = fromList . return . fromInteger
instance Num (Vector Z) where
(+) = adaptScalar addConstant add (flip addConstant)
negate = scale (-1)
(*) = adaptScalar scale mul (flip scale)
signum = vectorMapL Sign
abs = vectorMapL Abs
fromInteger = fromList . return . fromInteger
instance Num (Vector Float) where
(+) = adaptScalar addConstant add (flip addConstant)
negate = scale (-1)
(*) = adaptScalar scale mul (flip scale)
signum = vectorMapF Sign
abs = vectorMapF Abs
fromInteger = fromList . return . fromInteger
instance Num (Vector Double) where
(+) = adaptScalar addConstant add (flip addConstant)
negate = scale (-1)
(*) = adaptScalar scale mul (flip scale)
signum = vectorMapR Sign
abs = vectorMapR Abs
fromInteger = fromList . return . fromInteger
instance Num (Vector (Complex Double)) where
(+) = adaptScalar addConstant add (flip addConstant)
negate = scale (-1)
(*) = adaptScalar scale mul (flip scale)
signum = vectorMapC Sign
abs = vectorMapC Abs
fromInteger = fromList . return . fromInteger
instance Num (Vector (Complex Float)) where
(+) = adaptScalar addConstant add (flip addConstant)
negate = scale (-1)
(*) = adaptScalar scale mul (flip scale)
signum = vectorMapQ Sign
abs = vectorMapQ Abs
fromInteger = fromList . return . fromInteger
---------------------------------------------------
instance (Container Vector a, Num (Vector a), Fractional a) => Fractional (Vector a) where
fromRational n = fromList [fromRational n]
(/) = adaptScalar f divide g where
r `f` v = scaleRecip r v
v `g` r = scale (recip r) v
-------------------------------------------------------
instance Floating (Vector Float) where
sin = vectorMapF Sin
cos = vectorMapF Cos
tan = vectorMapF Tan
asin = vectorMapF ASin
acos = vectorMapF ACos
atan = vectorMapF ATan
sinh = vectorMapF Sinh
cosh = vectorMapF Cosh
tanh = vectorMapF Tanh
asinh = vectorMapF ASinh
acosh = vectorMapF ACosh
atanh = vectorMapF ATanh
exp = vectorMapF Exp
log = vectorMapF Log
sqrt = vectorMapF Sqrt
(**) = adaptScalar (vectorMapValF PowSV) (vectorZipF Pow) (flip (vectorMapValF PowVS))
pi = fromList [pi]
-------------------------------------------------------------
instance Floating (Vector Double) where
sin = vectorMapR Sin
cos = vectorMapR Cos
tan = vectorMapR Tan
asin = vectorMapR ASin
acos = vectorMapR ACos
atan = vectorMapR ATan
sinh = vectorMapR Sinh
cosh = vectorMapR Cosh
tanh = vectorMapR Tanh
asinh = vectorMapR ASinh
acosh = vectorMapR ACosh
atanh = vectorMapR ATanh
exp = vectorMapR Exp
log = vectorMapR Log
sqrt = vectorMapR Sqrt
(**) = adaptScalar (vectorMapValR PowSV) (vectorZipR Pow) (flip (vectorMapValR PowVS))
pi = fromList [pi]
-------------------------------------------------------------
instance Floating (Vector (Complex Double)) where
sin = vectorMapC Sin
cos = vectorMapC Cos
tan = vectorMapC Tan
asin = vectorMapC ASin
acos = vectorMapC ACos
atan = vectorMapC ATan
sinh = vectorMapC Sinh
cosh = vectorMapC Cosh
tanh = vectorMapC Tanh
asinh = vectorMapC ASinh
acosh = vectorMapC ACosh
atanh = vectorMapC ATanh
exp = vectorMapC Exp
log = vectorMapC Log
sqrt = vectorMapC Sqrt
(**) = adaptScalar (vectorMapValC PowSV) (vectorZipC Pow) (flip (vectorMapValC PowVS))
pi = fromList [pi]
-----------------------------------------------------------
instance Floating (Vector (Complex Float)) where
sin = vectorMapQ Sin
cos = vectorMapQ Cos
tan = vectorMapQ Tan
asin = vectorMapQ ASin
acos = vectorMapQ ACos
atan = vectorMapQ ATan
sinh = vectorMapQ Sinh
cosh = vectorMapQ Cosh
tanh = vectorMapQ Tanh
asinh = vectorMapQ ASinh
acosh = vectorMapQ ACosh
atanh = vectorMapQ ATanh
exp = vectorMapQ Exp
log = vectorMapQ Log
sqrt = vectorMapQ Sqrt
(**) = adaptScalar (vectorMapValQ PowSV) (vectorZipQ Pow) (flip (vectorMapValQ PowVS))
pi = fromList [pi]
|
