How to deal with floating point number precision in JavaScript

Question

I have the following dummy test script    x000D   x000D  function test     x000D    var x   0 1   0 2  x000D    document write x   x000D    x000D  test    x000D   x000D   x000D    This will print the result 0 020000000000000004 while it should just print 0 02  if you use your calculator   As far as I understood this is due to errors in the floating point multiplication precision   Does anyone have a good solution so that in such case I get the correct result 0 02  I know there are functions like toFixed or rounding would be another possibility  but I d like to really have the whole number printed without any cutting and rounding  Just wanted to know if one of you has some nice  elegant solution   Of course  otherwise I ll round to some 10 digits or so

User · Answer

var times   function  a  b        return Math round  a   b    100  100       ---or---  var fpFix   function  n        return Math round n   100  100      fpFix 0 1 0 2      - gt  0 02   ---also---  var fpArithmetic   function  op  x  y        var n                      x   y               -   x - y                   x   y                   x   y           op                return Math round n   100  100       --- as in ---  fpArithmetic      0 1  0 2      0 02  fpArithmetic      0 1  0 2      0 3  fpArithmetic  -   0 1  0 2      -0 1  fpArithmetic      0 2  0 1      2

User · Answer

0 6   3 it s awesome    For me this works fine   function dec  num         var p   100      return Math round  num   p     p      Very very simple

User · Answer

I had a nasty rounding error problem with mod 3  Sometimes when I should get 0 I would get  000   01  That s easy enough to handle  just test for  lt    01  But then sometimes I would get 2 99999999999998  OUCH   BigNumbers solved the problem  but introduced another  somewhat ironic  problem  When trying to load 8 5 into BigNumbers I was informed that it was really 8 4999    and had more than 15 significant digits  This meant BigNumbers could not accept it  I believe I mentioned this problem was somewhat ironic    Simple solution to ironic problem   x   Math round x 100      I only need 2 decimal places  if i needed 3 I would use 1 000  etc  x   x   100  xB   new BigNumber x

User · Answer

You just have to make up your mind on how many decimal digits you actually want - can t have the cake and eat it too  -   Numerical errors accumulate with every further operation and if you don t cut it off early it s just going to grow  Numerical libraries which present results that look clean simply cut off the last 2 digits at every step  numerical co-processors also have a  normal  and  full  lenght for the same reason  Cuf-offs are cheap for a processor but very expensive for you in a script  multiplying and dividing and using pov        Good math lib would provide floor x n  to do the cut-off for you   So at the very least you should make global var constant with pov 10 n  - meaning that you decided on the precision you need  -  Then do   Math floor x PREC LIM  PREC LIM     floor - you are cutting off  not rounding   You could also keep doing math and only cut-off at the end - assuming that you are only displaying and not doing if-s with results  If you can do that  then  toFixed      might be more efficient   If you are doing if-s comparisons and don t want to cut of then you also need a small constant  usually called eps  which is one decimal place higher than max expected error  Say that your cut-off is last two decimals - then your eps has 1 at the 3rd place from the last  3rd least significant  and you can use it to compare whether the result is within eps range of expected  0 02 -eps  lt  0 1 0 2  lt  0 02  eps

User · Answer

not elegant but does the job  removes trailing zeros   var num   0 1 0 2  alert parseFloat num toFixed 10        shows 0 02

User · Answer

Avoid dealing with floating points during the operation using Integers  As stated on the most voted answer until now  you can work with integers  that would mean to multiply all your factors by 10 for each decimal you are working with  and divide the result by the same number used   For example  if you are working with 2 decimals  you multiply all your factors by 100 before doing the operation  and then divide the result by 100   Here s an example  Result1 is the usual result  Result2 uses the solution    x000D   x000D  var Factor1  1110 7   x000D  var Factor2  2220 2   x000D  var Result1 Number Factor1  Number Factor2   x000D  var Result2   Number Factor1  100   Number Factor2  100   100  x000D  var Result3  Number parseFloat Number Factor1   parseFloat Number Factor2    toPrecision 2    x000D  document write  Result1    Result1   lt br gt Result2    Result2   lt br gt Result3    Result3   x000D   x000D   x000D    The third result is to show what happens when using parseFloat instead  which created a conflict in our case

User · Answer

I like Pedro Ladaria s solution and use something similar   function strip number        return  parseFloat number  toPrecision 12        Unlike Pedros solution this will round up 0 999   repeating and is accurate to plus minus one on the least significant digit   Note  When dealing with 32 or 64 bit floats  you should use toPrecision 7  and toPrecision 15  for best results   See this question for info as to why

User · Answer

I am not that much good at programming  but was really interested in this topic so I tried to understand how to solve that without using any libraries or scripts  I wrote this on scratchpad  var toAlgebraic   function f1  f2        let f1 base   Math pow 10  f1 split      1  length       let f2 base   Math pow 10  f2 split      1  length       f1   parseInt f1 replace                f2   parseInt f2 replace                 let dif  base      if  f1 base  gt  f2 base            dif   f1 base   f2 base          base   f1 base          f2   f2   dif        else           dif   f2 base   f1 base          base   f2 base          f1   f1   dif             return  f1   f2    base      console log 0 1   0 2   console log toAlgebraic  0 1    0 2       you might need refactor this code  because I am not good at programming

User · Answer

You could use a regex to check if the number ends with a long string of 0s followed by a small remainder      using max number of 0s   8  maximum remainder   4 digits x   0 1048000000000051 parseFloat x toString   replace       d   1-9  0 8   1-9  0 4      1    10       0 1048

User · Answer

How about toLocaleString method    gt  0 1 0 2  lt  0 30000000000000004   gt   0 1 0 2  toLocaleString    lt  0 3   If you want him to continue his computable   Number parseFloat  0 1 0 2  toLocaleString      Number prototype toLocaleString     Why not look at the document    gt  1000 021 0 02  lt  1000 0409999999999    gt   1000 021 0 02  toLocaleString    lt   1 000 041       why not use this   gt   1000 021 0 02  toLocaleString  zh   useGrouping  false maximumFractionDigits  10    lt   1000 041

User · Answer

Have a look at Fixed-point arithmetic  It will probably solve your problem  if the range of numbers you want to operate on is small  eg  currency   I would round it off to a few decimal values  which is the simplest solution

User · Answer

You can t represent most decimal fractions exactly with binary floating point types  which is what ECMAScript uses to represent floating point values   So there isn t an elegant solution unless you use arbitrary precision arithmetic types or a decimal based floating point type  For example  the Calculator app that ships with Windows now uses arbitrary precision arithmetic to solve this problem

User · Answer

You are right  the reason for that is limited precision of floating point numbers  Store your rational numbers as a division of two integer numbers and in most situations you ll be able to store numbers without any precision loss  When it comes to printing  you may want to display the result as fraction  With representation I proposed  it becomes trivial   Of course that won t help much with irrational numbers  But you may want to optimize your computations in the way they will cause the least problem  e g  detecting situations like sqrt 3  2

User · Answer

From the Floating-Point Guide      What can I do to avoid this problem       That depends on what kind of   calculations you   re doing          If you really need your results to add up exactly  especially when you   work with money  use a special decimal   datatype    If you just don   t want to see all those extra decimal places  simply   format your result rounded to a fixed   number of decimal places when   displaying it    If you have no decimal datatype available  an alternative is to work   with integers  e g  do money   calculations entirely in cents  But   this is more work and has some   drawbacks       Note that the first point only applies if you really need specific precise decimal behaviour  Most people don t need that  they re just irritated that their programs don t work correctly with numbers like 1 10 without realizing that they wouldn t even blink at the same error if it occurred with 1 3   If the first point really applies to you  use BigDecimal for JavaScript  which is not elegant at all  but actually solves the problem rather than providing an imperfect workaround

User · Answer

Use Number 1 234443  toFixed 2   it will print 1 23  function test        var x   0 1   0 2      document write Number x  toFixed 2      test

User · Answer

This function will determine the needed precision from the multiplication of two floating point numbers and return a result with the appropriate precision  Elegant though it is not   function multFloats a b     var atens   Math pow 10 String a  length - String a  indexOf      - 1          btens   Math pow 10 String b  length - String b  indexOf      - 1      return  a   atens     b   btens     atens   btens

User · Answer

Use   var x   0 1 0 2   x  Math round x Math pow 10 2   Math pow 10 2

User · Answer

You can use parseFloat   and toFixed   if you want to bypass this issue for a small operation   a   0 1  b   0 2   a   b   0 30000000000000004   c   parseFloat  a b  toFixed 2     c   0 3   a   0 3  b   0 2   a - b   0 09999999999999998   c   parseFloat  a-b  toFixed 2     c   0 1

User · Answer

To handle arbitrary floating number   function shorten num        num    0 000000001    to deal with  12 03999999997  form     num            return num replace      d   0 5   d       1     1     console log 1 2 1 9   1 3 1 8     false console log shorten 1 2 1 9    shorten 1 3 1 8      true

User · Answer

Problem  Floating point can t store all decimal values exactly  So when using floating point formats there will always be rounding errors on the input values  The errors on the inputs of course results on errors on the output  In case of a discrete function or operator there can be big differences on the output around the point where the function or operator is discrete   Input and output for floating point values  So  when using floating point variables  you should always be aware of this  And whatever output you want from a calculation with floating points should always be formatted conditioned before displaying with this in mind  When only continuous functions and operators are used  rounding to the desired precision often will do  don t truncate    Standard formatting features used to convert floats to string will usually do this for you  Because the rounding adds an error which can cause the total error to be more then half of the desired precision  the output should be corrected based on expected precision of inputs and desired precision of output  You should   Round inputs to the expected precision or make sure no values can be entered with higher precision  Add a small value to the outputs before rounding formatting them which is smaller than or equal to 1 4 of the desired precision and bigger than the maximum expected error caused by rounding errors on input and during calculation  If that is not possible the combination of the precision of the used data type isn t enough to deliver the desired output precision for your calculation      These 2 things are usually not done and in most cases the differences caused by not doing them are too small to be important for most users  but I already had a project where output wasn t accepted by the users without those corrections   Discrete functions or operators  like modula   When discrete operators or functions are involved  extra corrections might be required to make sure the output is as expected  Rounding and adding small corrections before rounding can t solve the problem  A special check correction on intermediate calculation results  immediately after applying the discrete function or operator might be required  For a specific case  modula operator   see my answer on question  Why does modulus operator return fractional number in javascript   Better avoid having the problem  It is often more efficient to avoid these problems by using data types  integer or fixed point formats  for calculations like this which can store the expected input without rounding errors  An example of that is that you should never use floating point values for financial calculations

User · Answer

Elegant  Predictable  and  Reusable  Let s deal with the problem in an elegant way reusable way  The following seven lines will let you access the floating point precision you desire on any number simply by appending  decimal to the end of the number  formula  or built in Math function    x000D   x000D     First extend the native Number object to handle precision  This populates x000D     the functionality to all math operations  x000D   x000D  Object defineProperty Number prototype   decimal     x000D    get  function decimal     x000D      Number precision    precision  in Number   Number precision   3  x000D      var f   Math pow 10  Number precision   x000D      return Math round  this   f     f  x000D      x000D      x000D   x000D   x000D     Now lets see how it works by adjusting our global precision level and  x000D     checking our results  x000D   x000D  console log   1 3   1 3   1 3   1  Right     x000D  console log  0 3333   0 3333   0 3333  decimal    1      true x000D   x000D  console log 0 3333 decimal      0 333 - A raw 4 digit decimal  trimmed to 3    x000D   x000D  Number precision   3  x000D  console log  Precision  3    x000D  console log  0 8   0 2  decimal      1 x000D  console log  0 08   0 02  decimal      0 1 x000D  console log  0 008   0 002  decimal      0 01 x000D  console log  0 0008   0 0002  decimal      0 001 x000D   x000D  Number precision   2  x000D  console log  Precision  2    x000D  console log  0 8   0 2  decimal      1 x000D  console log  0 08   0 02  decimal      0 1 x000D  console log  0 008   0 002  decimal      0 01 x000D  console log  0 0008   0 0002  decimal      0 x000D   x000D  Number precision   1  x000D  console log  Precision  1    x000D  console log  0 8   0 2  decimal      1 x000D  console log  0 08   0 02  decimal      0 1 x000D  console log  0 008   0 002  decimal      0 x000D  console log  0 0008   0 0002  decimal      0 x000D   x000D  Number precision   0  x000D  console log  Precision  0    x000D  console log  0 8   0 2  decimal      1 x000D  console log  0 08   0 02  decimal      0 x000D  console log  0 008   0 002  decimal      0 x000D  console log  0 0008   0 0002  decimal      0 x000D   x000D   x000D    Cheers

User · Answer

Solved it by first making both numbers integers  executing the expression and afterwards dividing the result to get the decimal places back   function evalMathematicalExpression a  b  op        const smallest   String a  lt  b   a   b       const factor   smallest length - smallest indexOf            for  let i   0  i  lt  factor  i              b    10          a    10             a   Math round a       b   Math round b       const m   10    factor      switch  op            case                  return  a   b    m          case  -               return  a - b    m          case                  return  a   b     m    2           case                  return a   b             throw  Unknown operator   op         Results for several operations  the excluded numbers are results from eval    0 1   0 002     0 102  0 10200000000000001  53   1000       1053  1053  0 1 - 0 3       -0 2  -0 19999999999999998  53 - -1000      1053  1053  0 3   0 0003    0 00009  0 00008999999999999999  100   25        2500  2500  0 9   0 03      30  30 000000000000004  100   50        2  2

User · Answer

To avoid this you should work with integer values instead of floating points  So when you want to have 2 positions precision work with the values   100  for 3 positions use 1000  When displaying you use a formatter to put in the separator   Many systems omit working with decimals this way  That is the reason why many systems work with cents  as integer  instead of dollars euro s  as floating point

User · Answer

Notice that for the general purpose use  this behavior is likely to be acceptable  The problem arises when comparing those floating points values to determine an appropriate action     With the advent of ES6  a new constant Number EPSILON is defined to determine the acceptable error margin   So instead of performing the comparison like this  0 1   0 2     0 3    which returns false   you can define a custom compare function  like this    function epsEqu x  y        return Math abs x - y   lt  Number EPSILON    console log epsEqu 0 1 0 2  0 3       true   Source   http   2ality com 2015 04 numbers-math-es6 html numberepsilon

User · Answer

I was looking the same fix and I worked out that if you add a whole number in like 1 and evaluate that console log 0 1   0 2   1    Which results in 1 02  This can be used to round the original x variable to the correct amount   Once the length of the decimal places 2 is retrieved in your example we can then use it with the toFixed   function to round the original x variable correctly   See inside the code as to what this function does in the commented sections    x000D   x000D  var myX  0 2   0 1  x000D  var myX  42 5-42 65  x000D  var myX  123 333 3 33 33333 3 333 333  x000D   x000D  console log myX   x000D     Outputs  example 1   0 020000000000000004 x000D     Outputs  example 2   -0 14999999999999858 x000D     Outputs  example 3   34458 630000000005 x000D     Wrong x000D   x000D  function fixRoundingError x    x000D     1  Rounds to the nearest 10 x000D        Also adds 1 to round of the value in some other cases  original x variable will be used later on to get the corrected result  x000D  var xRound   eval x toFixed 10     1  x000D     2  Using regular expression  remove all digits up until the decimal place of the corrected equation is evaluated   x000D  var xDec   xRound toString   replace   d     gm      x000D     3  Gets the length of the decimal places  x000D  var xDecLen   xDec length  x000D     4  Uses the original x variable along with the decimal length to fix the rounding issue  x000D  var x   eval x  toFixed xDecLen   x000D     5  Evaluate the new x variable to remove any unwanted trailing 0 s should there be any  x000D  return eval x   x000D    x000D   x000D  console log fixRoundingError myX    x000D     Outputs  example 1   0 02 x000D     Outputs  example 2   -0 15 x000D     Outputs  example 3   34458 63 x000D     Correct x000D   x000D   x000D    It returns the same value as the calculator in windows in every case I ve tried and also rounds of the result should there be any trailing 0 s automatically

User · Answer

decimal js  big js or bignumber js can be used to avoid floating-point manipulation problems in Javascript   0 1   0 2                                   0 020000000000000004 x   new Decimal 0 1  y   x times 0 2                               0 2  x times 0 2  equals 0 2                      true      big js  minimalist  easy-to-use  precision specified in decimal places  precision applied to division only       bignumber js  bases 2-64  configuration options  NaN  Infinity  precision specified in decimal places  precision applied to division only  base prefixes       decimal js  bases 2-64  configuration options  NaN  Infinity  non-integer powers  exp  ln  log  precision specified in significant digits  precision always applied  random numbers    link to detailed comparisons

User · Answer

The round   function at phpjs org works nicely  http   phpjs org functions round   num    01    06      yields 0 0699999999999 rnum   round num 12      yields 0 07

User · Answer

Output using the following function   var toFixedCurrency   function num       var num    num  toString        var one   new RegExp     d 1     test num       var two   new RegExp     d 2     test num       var result   null       if one   result   num replace      d 1         10          else if two   result   num replace      d 2   d       1          else   result   num 100         return result     function test        var x   0 1   0 2      document write toFixedCurrency x       test      Pay attention to the output toFixedCurrency x

User · Answer

Try my chiliadic arithmetic library  which you can see here  If you want a later version  I can get you one

User · Answer

The result you ve got is correct and fairly consistent across floating point implementations in different languages  processors and operating systems - the only thing that changes is the level of the inaccuracy when the float is actually a double  or higher    0 1 in binary floating points is like 1 3 in decimal  i e  0 3333333333333    forever   there s just no accurate way to handle it    If you re dealing with floats always expect small rounding errors  so you ll also always have to round the displayed result to something sensible  In return you get very very fast and powerful arithmetic because all the computations are in the native binary of the processor   Most of the time the solution is not to switch to fixed-point arithmetic  mainly because it s much slower and 99  of the time you just don t need the accuracy  If you re dealing with stuff that does need that level of accuracy  for instance financial transactions  Javascript probably isn t the best tool to use anyway  as you ve want to enforce the fixed-point types a static language is probably better    You re looking for the elegant solution then I m afraid this is it  floats are quick but have small rounding errors - always round to something sensible when displaying their results

User · Answer

Are you only performing multiplication   If so then you can use to your advantage a neat secret about decimal arithmetic   That is that NumberOfDecimals X    NumberOfDecimals Y    ExpectedNumberOfDecimals  That is to say that if we have 0 123   0 12 then we know that there will be 5 decimal places because 0 123 has 3 decimal places and 0 12 has two  Thus if JavaScript gave us a number like 0 014760000002 we can safely round to the 5th decimal place without fear of losing precision

User · Answer

I have a workaround here  Just multiplying with 10E x doesn t work with 1 1 for example   function sum a b       var tabA    a       split           var tabB    b       split           decA   tabA length gt 1 tabA 1  length 0      decB   tabB length gt 1 tabB 1  length 0      a    tabA 0  tabA 1   1 0      b    tabB 0  tabB 1   1 0      var diff   decA-decB      if diff  gt 0             a has more decimals than b         b b Math pow 10 diff           return  a b  Math pow 10 decA        else if  diff lt 0             a has more decimals than b         a a Math pow 10 -diff                   return  a b  Math pow 10 decB        else          return  a b  Math pow 10 decA                    scary but working

User · Answer

while adding two  float value its never give the precise values so we need to fixed this to certain number that will help us to compare    console log  parseFloat 0 1    parseFloat 0 2   toFixed 1     parseFloat 0 3  toFixed 1

User · Answer

You are looking for an sprintf implementation for JavaScript  so that you can write out floats with small errors in them  since they are stored in binary format  in a format that you expect   Try javascript-sprintf  you would call it like this   var yourString   sprintf    2f   yourNumber     to print out your number as a float with two decimal places   You may also use  Number toFixed    for display purposes  if you d rather not include  more files merely for floating point rounding to a given precision

User · Answer

From my point of view  the idea here is to round the fp number in order to have a nice short default string representation      The 53-bit significand precision gives from 15 to 17 significant decimal digits precision  2-53    1 11    10-16     If a decimal string with at most 15 significant digits is converted to IEEE 754 double-precision representation    and then converted back to a decimal string with the same number of digits  the final result should match the original string    If an IEEE 754 double-precision number is converted to a decimal string with at least 17 significant digits    and then converted back to double-precision representation  the final result must match the original number          With the 52 bits of the fraction  F  significand appearing in the memory format  the total precision is therefore 53 bits  approximately 16 decimal digits  53 log10 2     15 955   The bits are laid out as follows     wikipedia    0 1  toPrecision 100  - gt  0 1000000000000000055511151231257827021181583404541015625000000000000000000000000000000000000000000000   0 1 0 2  toPrecision 100  - gt  0 3000000000000000444089209850062616169452667236328125000000000000000000000000000000000000000000000000   Then  as far as I understand  we can round the value up to 15 digits to keep a nice string representation   10  Math floor 53   Math log10 2      1e15   eg   Math round  0 2 0 1    1e15     1e15 0 3    Math round  0 2 0 1    1e15     1e15  toPrecision 100  0 2999999999999999888977697537484345957636833190917968750000000000000000000000000000000000000000000000   The function would be   function roundNumberToHaveANiceDefaultStringRepresentation num         const integerDigits   Math floor Math log10 Math abs num   1       const mult   10   15-integerDigits      also consider integer digits     return Math round num   mult    mult

User · Answer

If you don t want to think about having to call functions each time  you can create a Class that handles conversion for you   class Decimal     constructor value   0  scale   4        this intervalValue   value      this scale   scale         get value         return this intervalValue         set value value        this intervalValue   Decimal toDecimal value  this scale          static toDecimal val  scale        const factor   10    scale      return Math round val   factor    factor          Usage   const d   new Decimal 0  4   d value   0 1   0 2                  0 3 d value   0 3 - 0 2                  0 1 d value   0 1   0 2 - 0 3            0 d value   5 551115123125783e-17      0 d value   1   9                      0 1111   Of course  when dealing with Decimal there are caveats   d value   1 3   1 3   1 3       1 d value -  1 3                  0 6667 d value -  1 3                  0 3334 d value -  1 3                  0 0001   You d ideally want to use a high scale  like 12   and then convert it down when you need to present it or store it somewhere  Personally  I did experiment with creating a UInt8Array and trying to create a precision value  much like the SQL Decimal type   but since Javascript doesn t let you overload operators  it just gets a bit tedious not being able to use basic math operators     -        and using functions instead like add    substract    mult    For my needs  it s not worth it   But if you do need that level of precision and are willing to endure the use of functions for math  then I recommend the decimal js library

User · Answer

For the mathematically inclined  http   docs oracle com cd E19957-01 806-3568 ncg goldberg html  The recommended approach is to use correction factors  multiply by a suitable power of 10 so that the arithmetic happens between integers    For example  in the case of 0 1   0 2  the correction factor is 10  and you are performing the calculation    gt  var x   0 1  gt  var y   0 2  gt  var cf   10  gt  x   y 0 020000000000000004  gt   x   cf     y   cf     cf   cf  0 02   A  very quick  solution looks something like   var  cf    function       function  shift x        var parts   x toString   split           return  parts length  lt  2    1   Math pow 10  parts 1  length         return function          return Array prototype reduce call arguments  function  prev  next    return prev     undefined    next     undefined   undefined   Math max prev   shift  next       -Infinity               Math a   function        var f    cf apply null  arguments   if f     undefined  return undefined    function cb x  y  i  o    return x   f   y      return Array prototype reduce call arguments  cb  0    f      Math s   function  l r    var f    cf l r   return  l   f - r   f    f      Math m   function        var f    cf apply null  arguments     function cb x  y  i  o    return  x f     y f     f   f       return Array prototype reduce call arguments  cb  1       Math d   function  l r    var f    cf l r   return  l   f     r   f        In this case    gt  Math m 0 1  0 2  0 02   I definitely recommend using a tested library like SinfulJS

User · Answer

Threw this together based on  SheetJs s answer  which I liked    x000D   x000D    getCorrectionFactor numberToCheck  number   number   x000D      var correctionFactor  number   1  x000D       x000D      if   Number isInteger numberToCheck     x000D        while   Number isInteger numberToCheck     x000D          correctionFactor    10  x000D          numberToCheck    correctionFactor  x000D          x000D        x000D   x000D      return correctionFactor  x000D      x000D   x000D   x000D

User · Answer

This works for me   function round up  value  precision          var pow   Math pow   10  precision         return   Math ceil   pow   value     Math ceil   pow   value - Math ceil   pow   value         pow      round up 341 536  2      341 54

User · Answer

I m finding BigNumber js meets my needs           A JavaScript library for arbitrary-precision decimal and non-decimal arithmetic       It has good documentation and the author is very diligent responding to feedback   The same author has 2 other similar libraries   Big js          A small  fast JavaScript library for arbitrary-precision decimal arithmetic  The little sister to bignumber js       and Decimal js          An arbitrary-precision Decimal type for JavaScript       Here s some code using BigNumber    x000D   x000D    function    x000D   x000D     x000D    var product   BigNumber  1  times  2     x000D        product   text product   x000D   x000D    var sum   BigNumber  1  plus  2     x000D        sum   text sum   x000D   x000D   x000D      x000D   lt script src  https   ajax googleapis com ajax libs jquery 1 11 1 jquery min js  gt  lt  script gt  x000D   x000D   lt  -- 1 4 1 is not the current version  but works for this example  -- gt  x000D   lt script src  http   cdn bootcss com bignumber js 1 4 1 bignumber min js  gt  lt  script gt  x000D   x000D   1  amp times   2    lt span id  product  gt  lt  span gt  lt br gt  x000D   1  amp plus   2    lt span id  sum  gt  lt  span gt  lt br gt  x000D   x000D   x000D

User · Answer

You can use library https   github com MikeMcl decimal js        it will   help  lot to give proper solution       javascript console output 95  722228 630  100   686117 1984999999     decimal library implementation      var firstNumber   new Decimal 95       var secondNumber   new Decimal 722228 630       var thirdNumber   new Decimal 100       var partialOutput   firstNumber times secondNumber       console log partialOutput       var output   new Decimal partialOutput  div thirdNumber       alert output valueOf         console log output valueOf      686117 1985

User · Answer

Surprisingly  this function has not been posted yet although others have similar variations of it  It is from the MDN web docs for Math round    It s concise and allows for varying precision    function precisionRound number  precision      var factor   Math pow 10  precision     return Math round number   factor    factor      console log precisionRound 1234 5678  1          expected output  1234 6  console log precisionRound 1234 5678  -1          expected output  1230   x000D   x000D  var inp   document querySelectorAll  input    x000D  var btn   document querySelector  button    x000D   x000D  btn onclick   function    x000D    inp 2  value   precisionRound  parseFloat inp 0  value    parseFloat inp 1  value    5    x000D     x000D   x000D    MDN function x000D  function precisionRound number  precision    x000D    var factor   Math pow 10  precision   x000D    return Math round number   factor    factor  x000D    x000D  button  x000D  display  block  x000D    x000D   lt input type  text  value  0 1  gt  x000D   lt input type  text  value  0 2  gt  x000D   lt button gt Get Product lt  button gt  x000D   lt input type  text  gt  x000D   x000D   x000D    UPDATE  Aug 20 2019 Just noticed this error  I believe it s due to a floating point precision error with Math round      precisionRound 1 005  2     produces 1  incorrect  should be 1 01   These conditions work correctly   precisionRound 0 005  2     produces 0 01 precisionRound 1 0005  3     produces 1 001 precisionRound 1234 5  0     produces 1235 precisionRound 1234 5  -1     produces 1230   Fix   function precisionRoundMod number  precision      var factor   Math pow 10  precision     var n   precision  lt  0   number   0 01   factor   number    return Math round  n   factor    factor      This just adds a digit to the right when rounding decimals  MDN has updated the Math round page so maybe someone could provide a  better solution

[javascript] How to deal with floating point number precision in JavaScript?

Examples related to javascript

Examples related to floating-point