> I've got an algorithm for computing the probability of a candidate in
> the presidential election winning a certain number of elector votes
> that looks like this (in pseudo-code):

>   define compute-ev-probabilites (state-probs)
>     probs = make-array 0 .. 538
>     probs[0] = 1
>     foreach state-prob in state-probs
>        fold-into probs state-prob.votes state-probs.probability

>   define fold-into (probs votes prob)
>     for i from 538 downto 0
>       probs[i] = probs[i] * (1 - prob)
>       if (votes <= i)
>         probs[i] = probs[i] + (prob * probs[i - votes])

> So far so good. Now I'd like to add this function which can back out
> the effects of a single state:

>   define back-out (probs votes prob)
>      for i from 0 to 538
>       if (= prob 1)
>         probs[i] (i + votes) < probs.length ? probs[i + votes] : 0
>       else
>         if (votes <= i) probs[i] = probs[i] - probs[i - votes] * prob
>         probs[i] = probs[i] / (1 - prob)

> Mathematically this works--I've actually implemented this in Common
> Lisp and when I use arbitrary-precision rational numbers it works
> perfectly. But when I use floating point numbers the computations in
> back-out get wildly out of whack. As best as I can tell this is
> because small errors introduced because (x * y) / y isn't necessarily
> exactly x get propagated throughout the whole array of probabilities
> and perhaps amplified by inaccuracies in the subtraction. (I can't
> just use rationals because I'm actually implementing this in
> Javascript whose only numeric type is double float.)

> Is there some obvious way to write this so I can still use floating
> point numbers but have back-out work properly. I'd be happy to trade
> some precision for reversibility.

> -Peter