Mercurial > repos > clustalomega > clustalomega
comparison clustalomega/clustal-omega-1.0.2/src/squid/vectorops.c @ 1:bc707542e5de
Uploaded
author | clustalomega |
---|---|
date | Thu, 21 Jul 2011 13:35:08 -0400 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
0:ff1768533a07 | 1:bc707542e5de |
---|---|
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 |