4 PROB ScoreToProb(SCORE Score)
\r
6 if (MINUS_INFINITY >= Score)
\r
8 return (PROB) pow(2.0, (double) Score/INTSCALE);
\r
12 //static const double log2e = log2(exp(1.0));
\r
14 //double lnTolog2(double ln)
\r
19 //double log2(double x)
\r
22 // return MINUS_INFINITY;
\r
24 // static const double dInvLn2 = 1.0/log(2.0);
\r
25 //// Multiply by inverse of log(2) just in case multiplication
\r
26 //// is faster than division.
\r
27 // return log(x)*dInvLn2;
\r
31 //SCORE ProbToScore(PROB Prob)
\r
34 // return MINUS_INFINITY;
\r
35 //// return (SCORE) floor(INTSCALE*log2(Prob));
\r
36 // return (SCORE) log2(Prob);
\r
39 WEIGHT DoubleToWeight(double d)
\r
42 return (WEIGHT) (INTSCALE*d);
\r
45 double WeightToDouble(WEIGHT w)
\r
47 return (double) w / (double) INTSCALE;
\r
50 SCORE DoubleToScore(double d)
\r
52 return (SCORE)(d*(double) INTSCALE);
\r
55 bool ScoreEq(SCORE s1, SCORE s2)
\r
57 return BTEq(s1, s2);
\r
60 static bool BTEq2(BASETYPE b1, BASETYPE b2)
\r
62 double diff = fabs(b1 - b2);
\r
65 double sum = fabs(b1) + fabs(b2);
\r
66 return diff/sum < 0.005;
\r
69 bool BTEq(double b1, double b2)
\r
71 return BTEq2((BASETYPE) b1, (BASETYPE) b2);
\r
74 //const double dLn2 = log(2.0);
\r
77 //double pow2(double x)
\r
79 // if (MINUS_INFINITY == x)
\r
81 // return exp(x*dLn2);
\r
84 //// lp2(x) = log2(1 + 2^-x), x >= 0
\r
85 //double lp2(double x)
\r
87 // return log2(1 + pow2(-x));
\r
90 // SumLog(x, y) = log2(2^x + 2^y)
\r
91 //SCORE SumLog(SCORE x, SCORE y)
\r
93 // return (SCORE) log2(pow2(x) + pow2(y));
\r
96 //// SumLog(x, y, z) = log2(2^x + 2^y + 2^z)
\r
97 //SCORE SumLog(SCORE x, SCORE y, SCORE z)
\r
99 // return (SCORE) log2(pow2(x) + pow2(y) + pow2(z));
\r
102 //// SumLog(w, x, y, z) = log2(2^w + 2^x + 2^y + 2^z)
\r
103 //SCORE SumLog(SCORE w, SCORE x, SCORE y, SCORE z)
\r
105 // return (SCORE) log2(pow2(w) + pow2(x) + pow2(y) + pow2(z));
\r
108 //SCORE lp2Fast(SCORE x)
\r
111 // const int iTableSize = 1000;
\r
112 // const double dRange = 20.0;
\r
113 // const double dScale = dRange/iTableSize;
\r
114 // static SCORE dValue[iTableSize];
\r
115 // static bool bInit = false;
\r
118 // for (int i = 0; i < iTableSize; ++i)
\r
119 // dValue[i] = (SCORE) lp2(i*dScale);
\r
122 // if (x >= dRange)
\r
124 // int i = (int) (x/dScale);
\r
125 // assert(i >= 0 && i < iTableSize);
\r
126 // SCORE dResult = dValue[i];
\r
127 // assert(BTEq(dResult, lp2(x)));
\r
131 //// SumLog(x, y) = log2(2^x + 2^y)
\r
132 //SCORE SumLogFast(SCORE x, SCORE y)
\r
134 // if (MINUS_INFINITY == x)
\r
136 // if (MINUS_INFINITY == y)
\r
137 // return MINUS_INFINITY;
\r
140 // else if (MINUS_INFINITY == y)
\r
145 // dResult = x + lp2Fast(x-y);
\r
147 // dResult = y + lp2Fast(y-x);
\r
148 // assert(SumLog(x, y) == dResult);
\r
152 //SCORE SumLogFast(SCORE x, SCORE y, SCORE z)
\r
154 // SCORE dResult = SumLogFast(x, SumLogFast(y, z));
\r
155 // assert(SumLog(x, y, z) == dResult);
\r
159 //SCORE SumLogFast(SCORE w, SCORE x, SCORE y, SCORE z)
\r
161 // SCORE dResult = SumLogFast(SumLogFast(w, x), SumLogFast(y, z));
\r
162 // assert(SumLog(w, x, y, z) == dResult);
\r
166 double VecSum(const double v[], unsigned n)
\r
169 for (unsigned i = 0; i < n; ++i)
\r
174 void Normalize(PROB p[], unsigned n)
\r
178 for (i = 0; i < n; ++i)
\r
181 Quit("Normalize, sum=0");
\r
182 for (i = 0; i < n; ++i)
\r
186 void NormalizeUnlessZero(PROB p[], unsigned n)
\r
190 for (i = 0; i < n; ++i)
\r
194 for (i = 0; i < n; ++i)
\r
198 void Normalize(PROB p[], unsigned n, double dRequiredTotal)
\r
202 for (i = 0; i < n; ++i)
\r
205 Quit("Normalize, sum=0");
\r
206 double dFactor = dRequiredTotal / dSum;
\r
207 for (i = 0; i < n; ++i)
\r
208 p[i] *= (PROB) dFactor;
\r
211 bool VectorIsZero(const double dValues[], unsigned n)
\r
213 for (unsigned i = 0; i < n; ++i)
\r
214 if (dValues[i] != 0.0)
\r
219 void VectorSet(double dValues[], unsigned n, double d)
\r
221 for (unsigned i = 0; i < n; ++i)
\r
225 bool VectorIsZero(const float dValues[], unsigned n)
\r
227 for (unsigned i = 0; i < n; ++i)
\r
228 if (dValues[i] != 0.0)
\r
233 void VectorSet(float dValues[], unsigned n, float d)
\r
235 for (unsigned i = 0; i < n; ++i)
\r
239 double Correl(const double P[], const double Q[], unsigned uCount)
\r
241 double dSumP = 0.0;
\r
242 double dSumQ = 0.0;
\r
243 for (unsigned n = 0; n < uCount; ++n)
\r
248 const double dMeanP = dSumP/uCount;
\r
249 const double dMeanQ = dSumQ/uCount;
\r
251 double dSum1 = 0.0;
\r
252 double dSum2 = 0.0;
\r
253 double dSum3 = 0.0;
\r
254 for (unsigned n = 0; n < uCount; ++n)
\r
256 const double dDiffP = P[n] - dMeanP;
\r
257 const double dDiffQ = Q[n] - dMeanQ;
\r
258 dSum1 += dDiffP*dDiffQ;
\r
259 dSum2 += dDiffP*dDiffP;
\r
260 dSum3 += dDiffQ*dDiffQ;
\r
264 const double dCorrel = dSum1 / sqrt(dSum2*dSum3);
\r
268 float Correl(const float P[], const float Q[], unsigned uCount)
\r
272 for (unsigned n = 0; n < uCount; ++n)
\r
277 const float dMeanP = dSumP/uCount;
\r
278 const float dMeanQ = dSumQ/uCount;
\r
283 for (unsigned n = 0; n < uCount; ++n)
\r
285 const float dDiffP = P[n] - dMeanP;
\r
286 const float dDiffQ = Q[n] - dMeanQ;
\r
287 dSum1 += dDiffP*dDiffQ;
\r
288 dSum2 += dDiffP*dDiffP;
\r
289 dSum3 += dDiffQ*dDiffQ;
\r
293 const float dCorrel = dSum1 / (float) sqrt(dSum2*dSum3);
\r
297 // Simple (but slow) function to compute Pearson ranks
\r
298 // that allows for ties. Correctness and simplicity
\r
299 // are priorities over speed here.
\r
300 void Rank(const float P[], float Ranks[], unsigned uCount)
\r
302 for (unsigned n = 0; n < uCount; ++n)
\r
304 unsigned uNumberGreater = 0;
\r
305 unsigned uNumberEqual = 0;
\r
306 unsigned uNumberLess = 0;
\r
307 double dValue = P[n];
\r
308 for (unsigned i = 0; i < uCount; ++i)
\r
313 else if (v < dValue)
\r
318 assert(uNumberEqual >= 1);
\r
319 assert(uNumberEqual + uNumberLess + uNumberGreater == uCount);
\r
320 Ranks[n] = (float) (1 + uNumberLess + (uNumberEqual - 1)/2.0);
\r
324 void Rank(const double P[], double Ranks[], unsigned uCount)
\r
326 for (unsigned n = 0; n < uCount; ++n)
\r
328 unsigned uNumberGreater = 0;
\r
329 unsigned uNumberEqual = 0;
\r
330 unsigned uNumberLess = 0;
\r
331 double dValue = P[n];
\r
332 for (unsigned i = 0; i < uCount; ++i)
\r
337 else if (v < dValue)
\r
342 assert(uNumberEqual >= 1);
\r
343 assert(uNumberEqual + uNumberLess + uNumberGreater == uCount);
\r
344 Ranks[n] = (double) (1 + uNumberLess + (uNumberEqual - 1)/2.0);
\r
348 FCOUNT SumCounts(const FCOUNT Counts[])
\r
351 for (int i = 0; i < 20; ++i)
\r