At a glance the error I see here looks that same as...

{const a = Math.floor(Math.random() * 1000000), b = Math.floor(Math.random() * 1000000), c = a + b, d = Math.floor(a / c * 1000) / 1000, e = Math.floor(b / c * 1000) / 1000, f = d * c, g = e * c, h = a - f, i = b - g;[a, b, c, d, e, f, g, h, i, h / a * 100, i / b * 100]}

It's inherent precision loss from rounding to three digits. If they're pumping through vote counts like that then it at leasts shows they're incompetent. They should not have been certified after code review if they have mistakes like that.

The question is if the data is purely for display purposes or not (though it seems odd to not provide the raw figures).

If they use data like this officially the match is within a percent difference that raises some serious questions.

It's a very common mistake in programming to try to provide figures based on derived figures. A lot of people get their flows wrong (order and retention of values). It's a big mistake often to derive c from a and b then only keep c then later when you need a or b take it from reversing the equation of c. Quite often operations are lossy for one.

You see this a lot in bad web development. For example, some javascript will set the upvotes to the number that is properly passed to Javascript in the HTML. Then another piece of Javascript will read it back from the HTML when it should have it already.

Honestly though, this is just normal for software outsourced to East Europe and Pakistan like Dominion does. They're cheap for a reason. I wouldn't trust the system as fare as I can throw it.

For fun see what happens when you play around with flooring one and ceiling another or playing around with distribution of rounding in various ways. Also see what happens when you make it each a million plus random zero to ten thousand.

Source: I'm an expert.

At a glance the error I see here looks that same as...

{const a = Math.floor(Math.random() * 1000000), b = Math.floor(Math.random() * 1000000), c = a + b, d = Math.floor(a / c * 1000) / 1000, e = Math.floor(b / c * 1000) / 1000, f = d * c, g = e * c, h = a - f, i = b - g;[a, b, c, d, e, f, g, h, i, h / a * 100, i / b * 100]}

It's inherent precision loss from rounding to three digits. If they're pumping through vote counts like that then it at leasts shows they're incompetent. They should not have been certified after code review if they have mistakes like that.

The question is if the data is purely for display purposes or not (though it seems odd to not provide the raw figures).

If they use data like this officially the match is within a percent difference that raises some serious questions.

It's a very common mistake in programming to try to provide figures based on derived figures. A lot of people get their flows wrong (order and retention of values). It's a big mistake often to derive c from a and b then only keep c then later when you need a or b take it from reversing the equation of c. Quite often operations are lossy for one.

Honestly though, this is just normal for software outsourced to East Europe and Pakistan like Dominion does. They're cheap for a reason. I wouldn't trust the system as fare as I can throw it.

For fun see what happens when you play around with flooring one and ceiling another or playing around with distribution of rounding in various ways. Also see what happens when you make it each a million plus random zero to ten thousand.

Source: I'm an expert.

At a glance the error I see here looks that same as...

{const a = Math.floor(Math.random() * 1000000), b = Math.floor(Math.random() * 1000000), c = a + b, d = Math.floor(a / c * 1000) / 1000, e = Math.floor(b / c * 1000) / 1000, f = d * c, g = e * c, h = a - f, i = b - g;[a, b, c, d, e, f, g, h, i, h / a * 100, i / b * 100]}

It's inherent precision loss from rounding to three digits. If they're pumping through vote counts like that then it at leasts shows they're incompetent. They should not have been certified after code review if they have mistakes like that.

The question is if the data is purely for display purposes or not (though it seems odd to not provide the raw figures).

If they use data like this officially the match is within a percent difference that raises some serious questions.

It's a very common mistake in programming to try to provide figures based on derived figures. A lot of people get their flows wrong.

Honestly though, this is just normal for software outsourced to East Europe and Pakistan like Dominion does. They're cheap for a reason. I wouldn't trust the system as fare as I can throw it.

For fun see what happens when you play around with flooring one and ceiling another or playing around with distribution of rounding in various ways. Also see what happens when you make it each a million plus random zero to ten thousand.

Source: I'm an expert.

At a glance the error I see here looks that same as...

{const a = Math.floor(Math.random() * 1000000), b = Math.floor(Math.random() * 1000000), c = a + b, d = Math.floor(a / c * 1000) / 1000, e = Math.floor(b / c * 1000) / 1000, f = d * c, g = e * c, h = a - f, i = b - g;[a, b, c, d, e, f, g, h, i, h / a * 100, i / b * 100]}

It's inherent precision loss from rounding to three digits. If they're pumping through vote counts like that then it at leasts shows they're incompetent. They should not have been certified after code review if they have mistakes like that.

The question is if the data is purely for display purposes or not (though it seems odd to not provide the raw figures).

If they use data like this officially the match is within a percent difference that raises some serious questions.

It's a very common mistake in programming to try to provide figures based on derived figures. A lot of people get their flows wrong.

Honestly though, this is just normal for software outsourced to East Europe and Pakistan like Dominion does. They're cheap for a reason. I wouldn't trust the system as far as I can throw it.

Source: I'm an expert.

At a glance the error I see here looks that same as...

{const a = Math.floor(Math.random() * 1000000), b = Math.floor(Math.random() * 1000000), c = a + b, d = Math.floor(a / c * 1000) / 1000, e = Math.floor(b / c * 1000) / 1000, f = d * c, g = e * c, h = a - f, i = b - g;[a, b, c, d, e, f, g, h, i, h / a * 100, i / b * 100]}

It's inherent precision loss from rounding to three digits. If they're pumping through vote counts like that then it at leasts shows they're incompetent. They should not have been certified after code review if they have mistakes like that.

The question is if the data is purely for display purposes or not (though it seems odd to not provide the raw figures).

If they use data like this officially the match is within a percent difference that raises some serious questions.

It's a very common mistake in programming to try to provide figures based on derived figures. A lot of people get their flows wrong.

Honestly though, this is just normal for software outsourced to East Europe and Pakistan like Dominion does. They're cheap for a reason. I wouldn't trust the system as fare as I can throw it.

Source: I'm an expert.

At a glance the error I see here looks that same as...

{const a = Math.floor(Math.random() * 1000000), b = Math.floor(Math.random() * 1000000), c = a + b, d = Math.floor(a / c * 1000) / 1000, e = Math.floor(b / c * 1000) / 1000, f = d * c, g = e * c, h = a - f, i = b - g;[a, b, c, d, e, f, g, h, i, h / a * 100, i / b * 100]}

It's inherent precision loss from rounding to three digits. If they're pumping through vote counts like that then it at leasts shows they're incompetent. They should not have been certified after code review if they have mistakes like that.

The question is if the data is purely for display purposes or not (though it seems odd to not provide the raw figures).

If they use data like this officially the match is within a percent difference that raises some serious questions.

It's a very common mistake in programming to try to provide figures based on derived figures. A lot of people get their flows wrong.

Source: I'm an expert.

At a glance the error I see here looks that same as...

{const a = Math.floor(Math.random() * 1000000), b = Math.floor(Math.random() * 1000000), c = a + b, d = Math.floor(a / c * 1000) / 1000, e = Math.floor(b / c * 1000) / 1000, f = d * c, g = e * c, h = a - f, i = b - g;[a, b, c, d, e, f, g, h, i, h / a * 100, i / b * 100]}

It's inherent precision loss from rounding to three digits. If they're pumping through vote counts like that then it at leasts shows they're incompetent. They should not have been certified after code review if they have mistakes like that.

The question is if the data is purely for display purposes or not (though it seems odd to not provide the raw figures).

If they use data like this officially the match is within a percent difference that raises some serious questions.

Source: I'm an expert.

At a glance the error I see here looks that same as...

{const a = Math.floor(Math.random() * 1000000), b = Math.floor(Math.random() * 1000000), c = a + b, d = Math.floor(a / c * 1000) / 1000, e = Math.floor(b / c * 1000) / 1000, f = d * c, g = e * c, h = a - f, i = b - g;[a, b, c, d, e, f, g, h, i, h / a * 100, i / b * 100]}

It's inherent precision loss from rounding to three digits. If they're pumping through vote counts like that then it at leasts shows they're incompetent. They should not have been certified after code review if they have mistakes like that.

The question is if the data is purely for display purposes or not (though it seems odd to not provide the raw figures).

If they use data like this officially the match is within a percent difference that raises some serious questions. You can have fun like see what happens when you make it tight like random 0 to 10000 plus a million then see what happens when you floor one, ceil the other or basically bias the rounding scheme.

At a glance the error I see here looks that same as...

{const a = Math.floor(Math.random() * 1000000), b = Math.floor(Math.random() * 1000000), c = a + b, d = Math.floor(a / c * 1000) / 1000, e = Math.floor(b / c * 1000) / 1000, f = d * c, g = e * c, h = a - f, i = b - g;[a, b, c, d, e, f, g, h, i, h / a * 100, i / b * 100]}

It's inherent precision loss from rounding to three digits. If they're pumping through vote counts like that then it at leasts shows they're incompetent. They should not have been certified after code review if they have mistakes like that.

The question is if the data is purely for display purposes or not (though it seems odd to not provide the raw figures).

If they use data like this officially the match is within a percent difference that raises some serious questions.

At a glance the error I see here looks that same as...

{const a = Math.floor(Math.random() * 1000000), b = Math.floor(Math.random() * 1000000), c = a + b, d = Math.floor(a / c * 1000) / 1000, e = Math.floor(b / c * 1000) / 1000;[a, b, c, d, e, d * c, e * c]}

It's inherent precision loss from rounding to three digits. If they're pumping through vote counts like that then it at leasts shows they're incompetent. They should not have been certified after code review if they have mistakes like that.

The question is if the data is purely for display purposes or not (though it seems odd to not provide the raw figures).

If they use data like this officially the match is within a percent difference that raises some serious questions.

At a glance the error I see here looks that same as...

{const a = Math.floor(Math.random() * 1000000), b = Math.floor(Math.random() * 1000000), c = a + b, d = Math.floor(a / c * 1000) / 1000, e = Math.floor(b / c * 1000) / 1000;[a, b, c, d, e, d * c, e * c]}

It's inherent precision loss from rounding to three digits.