1
|
1 /* vectorops.c
|
|
2 * Operations on vectors of floats or doubles.
|
|
3 *
|
|
4 * DSet(), FSet() - set all items in vector to value.
|
|
5 * DScale(), FScale() - multiply all items in vector by scale
|
|
6 * DSum(), FSum() - return sum of values in vector
|
|
7 * DAdd(), FAdd() - add vec2 to vec1.
|
|
8 * DCopy(), FCopy() - set vec1 to be same as vec2.
|
|
9 * DDot(), FDot() - return dot product of two vectors.
|
|
10 * DMax(), FMax() - return value of maximum element in vector
|
|
11 * DMin(), FMin() - return value of minimum element in vector
|
|
12 * DArgMax(), FArgMax() - return index of maximum element in vector
|
|
13 * DArgMin(), FArgMin() - return index of minimum element in vector
|
|
14 *
|
|
15 * DNorm(), FNorm() - normalize a probability vector of length n.
|
|
16 * DLog(), FLog() - convert to log probabilities
|
|
17 * DExp(), FExp() - convert log p's back to probabilities
|
|
18 * DLogSum(), FLogSum() - given vector of log p's; return log of summed p's.
|
|
19 *
|
|
20 * SRE, Tue Oct 1 15:23:25 2002 [St. Louis]
|
|
21 * CVS $Id: vectorops.c,v 1.1 2002/10/09 14:26:09 eddy Exp)
|
|
22 */
|
|
23
|
|
24 #include <stdlib.h>
|
|
25 #include <math.h>
|
|
26 #include <float.h>
|
|
27 #include "vectorops.h"
|
|
28
|
|
29 void
|
|
30 DSet(double *vec, int n, double value)
|
|
31 {
|
|
32 int x;
|
|
33 for (x = 0; x < n; x++) vec[x] = value;
|
|
34 }
|
|
35
|
|
36 void
|
|
37 FSet(float *vec, int n, float value)
|
|
38 {
|
|
39 int x;
|
|
40 for (x = 0; x < n; x++) vec[x] = value;
|
|
41 }
|
|
42
|
|
43 void
|
|
44 DScale(double *vec, int n, double scale)
|
|
45 {
|
|
46 int x;
|
|
47 for (x = 0; x < n; x++) vec[x] *= scale;
|
|
48 }
|
|
49
|
|
50 void
|
|
51 FScale(float *vec, int n, float scale)
|
|
52 {
|
|
53 int x;
|
|
54 for (x = 0; x < n; x++) vec[x] *= scale;
|
|
55 }
|
|
56
|
|
57 double
|
|
58 DSum(double *vec, int n)
|
|
59 {
|
|
60 double sum = 0.;
|
|
61 int x;
|
|
62 for (x = 0; x < n; x++) sum += vec[x];
|
|
63 return sum;
|
|
64 }
|
|
65
|
|
66 float
|
|
67 FSum(float *vec, int n)
|
|
68 {
|
|
69 float sum = 0.;
|
|
70 int x;
|
|
71 for (x = 0; x < n; x++) sum += vec[x];
|
|
72 return sum;
|
|
73 }
|
|
74
|
|
75 void
|
|
76 DAdd(double *vec1, double *vec2, int n)
|
|
77 {
|
|
78 int x;
|
|
79 for (x = 0; x < n; x++) vec1[x] += vec2[x];
|
|
80 }
|
|
81
|
|
82 void
|
|
83 FAdd(float *vec1, float *vec2, int n)
|
|
84 {
|
|
85 int x;
|
|
86 for (x = 0; x < n; x++) vec1[x] += vec2[x];
|
|
87 }
|
|
88
|
|
89 void
|
|
90 DCopy(double *vec1, double *vec2, int n)
|
|
91 {
|
|
92 int x;
|
|
93 for (x = 0; x < n; x++) vec1[x] = vec2[x];
|
|
94 }
|
|
95
|
|
96 void
|
|
97 FCopy(float *vec1, float *vec2, int n)
|
|
98 {
|
|
99 int x;
|
|
100 for (x = 0; x < n; x++) vec1[x] = vec2[x];
|
|
101 }
|
|
102
|
|
103 double
|
|
104 DDot(double *vec1, double *vec2, int n)
|
|
105 {
|
|
106 double result = 0.;
|
|
107 int x;
|
|
108 for (x = 0; x < n; x++) result += vec1[x] * vec2[x];
|
|
109 return result;
|
|
110 }
|
|
111
|
|
112 float
|
|
113 FDot(float *vec1, float *vec2, int n)
|
|
114 {
|
|
115 float result = 0.;
|
|
116 int x;
|
|
117 for (x = 0; x < n; x++) result += vec1[x] * vec2[x];
|
|
118 return result;
|
|
119 }
|
|
120
|
|
121 double
|
|
122 DMax(double *vec, int n)
|
|
123 {
|
|
124 int i;
|
|
125 double best;
|
|
126
|
|
127 best = vec[0];
|
|
128 for (i = 1; i < n; i++)
|
|
129 if (vec[i] > best) best = vec[i];
|
|
130 return best;
|
|
131 }
|
|
132
|
|
133 float
|
|
134 FMax(float *vec, int n)
|
|
135 {
|
|
136 int i;
|
|
137 float best;
|
|
138
|
|
139 best = vec[0];
|
|
140 for (i = 1; i < n; i++)
|
|
141 if (vec[i] > best) best = vec[i];
|
|
142 return best;
|
|
143 }
|
|
144
|
|
145 double
|
|
146 DMin(double *vec, int n)
|
|
147 {
|
|
148 int i;
|
|
149 double best;
|
|
150
|
|
151 best = vec[0];
|
|
152 for (i = 1; i < n; i++)
|
|
153 if (vec[i] < best) best = vec[i];
|
|
154 return best;
|
|
155 }
|
|
156
|
|
157 float
|
|
158 FMin(float *vec, int n)
|
|
159 {
|
|
160 int i;
|
|
161 float best;
|
|
162
|
|
163 best = vec[0];
|
|
164 for (i = 1; i < n; i++)
|
|
165 if (vec[i] < best) best = vec[i];
|
|
166 return best;
|
|
167 }
|
|
168
|
|
169 double
|
|
170 DArgMax(double *vec, int n)
|
|
171 {
|
|
172 int i;
|
|
173 int best = 0;
|
|
174
|
|
175 for (i = 1; i < n; i++)
|
|
176 if (vec[i] > vec[best]) best = i;
|
|
177 return best;
|
|
178 }
|
|
179
|
|
180 float
|
|
181 FArgMax(float *vec, int n)
|
|
182 {
|
|
183 int i;
|
|
184 int best = 0;
|
|
185
|
|
186 for (i = 1; i < n; i++)
|
|
187 if (vec[i] > vec[best]) best = i;
|
|
188 return best;
|
|
189 }
|
|
190
|
|
191 double
|
|
192 DArgMin(double *vec, int n)
|
|
193 {
|
|
194 int i;
|
|
195 int best = 0;
|
|
196 for (i = 1; i < n; i++)
|
|
197 if (vec[i] < vec[best]) best = i;
|
|
198 return best;
|
|
199 }
|
|
200
|
|
201 float
|
|
202 FArgMin(float *vec, int n)
|
|
203 {
|
|
204 int i;
|
|
205 int best = 0;
|
|
206
|
|
207 for (i = 1; i < n; i++)
|
|
208 if (vec[i] < vec[best]) best = i;
|
|
209 return best;
|
|
210 }
|
|
211
|
|
212 void
|
|
213 DNorm(double *vec, int n)
|
|
214 {
|
|
215 int x;
|
|
216 double sum;
|
|
217
|
|
218 sum = DSum(vec, n);
|
|
219 if (sum != 0.0) for (x = 0; x < n; x++) vec[x] /= sum;
|
|
220 else for (x = 0; x < n; x++) vec[x] = 1. / (double) n;
|
|
221 }
|
|
222
|
|
223 void
|
|
224 FNorm(float *vec, int n)
|
|
225 {
|
|
226 int x;
|
|
227 float sum;
|
|
228
|
|
229 sum = FSum(vec, n);
|
|
230 if (sum != 0.0) for (x = 0; x < n; x++) vec[x] /= sum;
|
|
231 else for (x = 0; x < n; x++) vec[x] = 1. / (float) n;
|
|
232 }
|
|
233
|
|
234 void
|
|
235 DLog(double *vec, int n)
|
|
236 {
|
|
237 int x;
|
|
238 for (x = 0; x < n; x++)
|
|
239 if (vec[x] > 0.) vec[x] = log(vec[x]);
|
|
240 else vec[x] = -DBL_MAX;
|
|
241 }
|
|
242
|
|
243 void
|
|
244 FLog(float *vec, int n)
|
|
245 {
|
|
246 int x;
|
|
247 for (x = 0; x < n; x++)
|
|
248 if (vec[x] > 0.) vec[x] = log(vec[x]);
|
|
249 else vec[x] = -FLT_MAX;
|
|
250 }
|
|
251
|
|
252 void
|
|
253 DExp(double *vec, int n)
|
|
254 {
|
|
255 int x;
|
|
256 for (x = 0; x < n; x++) vec[x] = exp(vec[x]);
|
|
257 }
|
|
258
|
|
259 void
|
|
260 FExp(float *vec, int n)
|
|
261 {
|
|
262 int x;
|
|
263 for (x = 0; x < n; x++) vec[x] = exp(vec[x]);
|
|
264 }
|
|
265
|
|
266 float
|
|
267 DLogSum(double *vec, int n)
|
|
268 {
|
|
269 int x;
|
|
270 double max, sum;
|
|
271
|
|
272 max = DMax(vec, n);
|
|
273 sum = 0.0;
|
|
274 for (x = 0; x < n; x++)
|
|
275 if (vec[x] > max - 50.)
|
|
276 sum += exp(vec[x] - max);
|
|
277 sum = log(sum) + max;
|
|
278 return sum;
|
|
279 }
|
|
280
|
|
281 float
|
|
282 FLogSum(float *vec, int n)
|
|
283 {
|
|
284 int x;
|
|
285 float max, sum;
|
|
286
|
|
287 max = FMax(vec, n);
|
|
288 sum = 0.0;
|
|
289 for (x = 0; x < n; x++)
|
|
290 if (vec[x] > max - 50.)
|
|
291 sum += exp(vec[x] - max);
|
|
292 sum = log(sum) + max;
|
|
293 return sum;
|
|
294 }
|
|
295
|
|
296
|
|
297
|