#floating point arithmetic

[alanshemper]

The Perils of Floating Point

by Bruce M. Bush

Copyright (c) 1996 Lahey Computer Systems, Inc. Permission to copy is granted with acknowledgement of the source.

Many great engineering and scientific advances of recent decades would not have been possible without the floating-point capabilities of digital computers. Still, some results of floating-point calculations look pretty strange, even to people with years of mathematical experience. I will attempt to explain the causes of some of these strange results and give some suggestions where appropriate.

Floating-point representations and arithmetic are inexact, but I don't believe that is particularly troublesome to most programmers. Many input values are measurements, which are inherently inexact, so the question about the output values isn't whether there is error, but how much error should be expected. However, when you can compute a more accurate result in your head than your computer can with its floating-point, you start to get suspicious.

I have programmed my examples in FORTRAN for a couple of reasons: 1. More floating-point calculations are performed in FORTRAN than any other computer language. 2. I work for a company, Lahey Computer Systems, that develops and sells FORTRAN language systems.

[imfbsl]

“Wherein Patrick Cousot gives me more reason to fear floating point numbers”

huh

[obscurejavascript]

Correct Decimal Calculations in JavaScript

Some decimal calculations will give seemingly strange results like so:

console.log(0.1 + 0.2); // 0.30000000000000004

This is not actually a bug, it is do with with JavaScript's Number implementation which is using a Base 2 system instead of a Base 10 one. You can read more about that here. Anyways, the simplest way to deal with this is to always ensure you are working with integers. To fix the above example:

const result = ((0.1 * 10) + (0.2 * 10)) / 10; console.log(result); // 0.3

Although once you start moving beyond basic calculations this becomes increasingly difficult, especially when involving multiplication. For example, here is an attempt at getting the total compound interest after a set number of years:

function getTotalCompoundInterest(interest, years) { const epsilon = 10000; return Math.pow(interest * epsilon, years) / Math.pow(epsilon, years); } console.log('\nCorrect Compound Interest Calculation'); console.log(getTotalCompoundInterest(1.10, 5)); // 1.61051 console.log(getTotalCompoundInterest(1.12, 5)); // 1.7623416832000016 console.log(getTotalCompoundInterest1(1.1273, 5)); // 1.8205287217241934

I was able to make the first interest rate convert to a decimal, but not the second. A more complex calculation will be needed to fix that. Instead a library that does computations in Base 10 should be used. Here is an example with decimal.js:

const Decimal = require('decimal.js'); function getTotalCompoundInterest(interest, years) { return new Decimal(interest).toPower(years).toNumber(); } console.log(getTotalCompoundInterest(1.10, 5)); // 1.61051 console.log(getTotalCompoundInterest(1.12, 5)); // 1.7623416832 console.log(getTotalCompoundInterest2(1.1273, 5)); // 1.8205287217241937

Notice how the last value for this calculation is actaully correct unlike the original strategy which could not have been corrected even with rounding.

Github Location: https://github.com/Jacob-Friesen/obscurejs/blob/master/2019/decimalOperations.js

[obscurejavascript]

Floating Point Arithmetic In JavaScript

If you have ever done mathematical operations with decimal numbers in JavaScript you may have noticed some weird behaviour:

var increment = function(base, increment) { return base + increment; }; console.log('1.0 + 2.0 =', increment(1.0, 2.0));// 3 console.log('0.1 + 0.2 =', increment(0.1, 0.2));// 0.30000000000000004 console.log('0.01 + 0.06 =', increment(0.01, 0.06));// 0.06999999999999999 console.log('0.001 + 0.006 =', increment(0.001, 0.006));// 0.007 console.log('0.0001 + 0.0006 =', increment(0.0001, 0.0005));// 0.0006000000000000001

This looks like there is a bug in JavaScript's arithmetic engine, but it actaully is not. Computing is based on a base 2 number system (Technically a binary floating point system), but our number system is a base 10 system. This means that computers cannot accurately represent certian decimal numbers without help. Which means languages like JavaScript that do not focus on numerical computations can sometimes produce incorrect results when doing operations on decimal numbers like above.

There are many tactics to dealing with this, but the simplist is to just avoid working with decimal numbers altogether. Specifically, convert the decimal numbers into integers by multiplying by a high enough 10 multiple, do the calculation and then convert the result to a decimal again:

var add = function(x, y) { var APPROX = 10000; return ((x * APPROX) + (y * APPROX))/APPROX; }; console.log('1.0 + 2.0 =', add(1.0, 2.0));// 3 console.log('0.1 + 0.2 =', add(0.1, 0.2));// 0.03 console.log('0.01 + 0.06 =', add(0.01, 0.06));// 0.07 console.log('0.001 + 0.006 =', add(0.001, 0.006));// 0.007 console.log('0.0001 + 0.0006 =', add(0.0001, 0.0005));// 0.0006

Here up to 4 digits could be used, so any numbers that are sent in are multiplied by 10000 to get rid of any decimal points. One thing to note though; JavaScript is not intended for complex mathematical operations, so when you are faced with decimal operations it should cause you to question whether you are using the right tool for the job. For example, instead of computing floating points in client side code it may be better to get the server to return already computed values.

Github Location https://github.com/Jacob-Friesen/obscurejs/blob/master/2015/floatingPointArithmetic.js

[icetigris]

What Every Computer Scientist Should Know About Floating-Point Arithmetic

Note –

This appendix is an edited reprint of the paper What Every Computer Scientist Should Know About Floating-Point Arithmetic, by David Goldberg, published in the March, 1991 issue of Computing Surveys. Copyright 1991, Association for Computing Machinery, Inc., reprinted by permission.

  Abstract

  Floating-point arithmetic is considered an esoteric subject by many people. This is rather surprising because floating-point is ubiquitous in computer systems. Almost every language has a floating-point datatype; computers from PCs to supercomputers have floating-point accelerators; most compilers will be called upon to compile floating-point algorithms from time to time; and virtually every operating system must respond to floating-point exceptions such as overflow. This paper presents a tutorial on those aspects of floating-point that have a direct impact on designers of computer systems. It begins with background on floating-point representation and rounding error, continues with a discussion of the IEEE floating-point standard, and concludes with numerous examples of how computer builders can better support floating-point.

[milk-app]

Milk 1.2.3: The Third Decimal Group

If you purchased Milk directly from our store you may have noticed that you haven’t received a notification about the update to version 1.2.3 within the app. If you check manually the app will tell you that it’s up to date.

The problem is when we wrote the version checking code we forgot to consider minor updates in which only the third decimal group will change (i.e., the ‘3’ in 1.2.3). The app currently cannot make any distinction between 1.2 and 1.2.3 because 1.2.3 gets converted to the floating point value 1.2. Oops!

Not to worry—the next update will see a change in the second decimal group only, for which you will receive a notification, and we’ll make sure to fix this in that update.