Please enable JavaScript.

Coggle requires JavaScript to display documents.

How to Round Numbers in Python (Article here) (Infrastructure…

- - - - Round the number n to p decimal places by first shifting the decimal point in n by p places by multiplying n by 10^p(10 raised to the pth power) to get a nem number m
        
        Look at the digit d in the first decimal place of m. if d is less than 5, round m down to the nearest integer. Otherwise, round m up
        
        Shift the decimal point back p places by dividing m by 10^p
        
        round(1.5)=round(2.5)=2
        
        Round behaves according to particular rounding strategy
        and What?
        
        Can the way I round numbers really have hat much of an impact?
  - - - actual value only lost about $3.55.
        truncated value lost almost all of money
    - - actual value is almost equal to rounded value
        
        How you round is important. It is necessary to investigate what the different rounding methods are and how to implement each one in pure Python
  - - - Multiplying the number by 10^p(10 raised to the pth power) to shift the decimal point p places to the right
        
        Round towards negative bias on positive values
        
        Round towards positive bias on negative values
        
        Round towards zero bias: No round bias
      - Taking the integer part of the new number with int()
      - Shifting the decimal place p places back to the left by dividing by 10^p
      - All three of techniques are rather crude when it comes to preserving a reasonable amount of precision for a given number, because it could remove precision and alter computations
    - - Multiplying the number by 10^p(10 raised to the pth power) to shift the decimal point p places to the right
        
        Round towards positive infinity bias
      - Taking the integer part of the new number with math.ceil()
        "ceil" describe the nearest integer that is greater than or equal to a given number
      - Shifting the decimal place p places back to the left by dividing by 10^p
  - - - Introduce the notion of rounding bias
        
        Describe how rounding affects data?
        
        Typically, we are interested in rounding to the nearest number with some specified precision, instead of just rounding everything up or down.With this situation, we must assign a tiebreaker for every tie like 1.25 is the tie with respect to 1.2 and 1.3, and the strategy round to the greater of the two possible numbers is often accepted
      - Test statistics.mean() for random data and rounded data after applying three rounding strategies
        
        The value is always rounded down in the direction of negative infinity
        
        The value is always chopped off no matter what it is positive or negative
        
        The value is always rounded up in the direction of positive infinity
        
        Both round half up and round half down have no bias in general
        
        Rounding data with lots of ties does introduce a bias
        
        Round half up strategy introduces a round towards positive infinity bias
        
        Round half down strategy introduces a round towards negative infinity bias
        
        Neither of round half up and round half down strategy is symmetric around zero
        
        1 more item...
        
        Central Node have no meaning
        
        No floating-point representation error
        
        Different rounding strategy has different rounding bias
        
        Suffer from floating-point representation error
        
        Different rounding strategy has different rounding bias
  - - - If the digit just after the shifted decimal point is less than 5, then adding 0.5 won't change the integer part of the shifted value , so the floor is equal to the integer part
      - If the first digit after the decimal place is greater than or equal to 5, then adding 0.5 will increase the integer part of the shifted value by 1, so the floor is equal to this larger integer
    - - Floating-point representation error: Most modern computers store floating-point numbers as binary decimals with 53-bit precision. Only numbers that have finite binary decimal representations that can be expressed in 53 bits are stored as an exact value. Not every number has a finite binary decimal representation
        
        Floating-point do not have exact precision, and therefore should not be used in situations where precision is paramount. For applications where the exact precision is necessary, you can use the Decimal class from Python's decimal module
  - - - If the digit just after the shifted decimal point is greater than or equal to 5,then subtracting 0.5 won't change the integer part of the shifted value, so the ceil is equal to the integer part
      - If the digit just after the shifted decimal point is less than 5, then subtracting 0.5 will decrease the integer part of the shifted value by 1, so the ceil is equal to this smaller integer
  - - - Look at the digit just after the shifted decimal point, if the number is positive and this digit is greater than or equal to 5,or the number is negative and this number is less than 5, then round up
      - Look at the digit just after the shifted decimal point, if the number is positive and this digit is greater than or equal to 5,or the number is negative and this number is less than 5, then round up
    - - Round half away from zero strategy eliminates rounding bias well in datasets that have an equal or similar number of positive and negative ties:Round towards zero bias
        
        However, round half away from zero will exhibit a rounding bias when you round every number in datasets with only positive ties, only negative ties, or more ties of one sign than the other
        
        How do you handle situations where the number of positive and negative ties are drastically different? The answer to this question brings us full circle to the Python's built-in round() function.
  - - - The round() function is nearly free from bias: Round towards zero bias
        
        Rounding bias can still be introduced if the majority of the ties in your dataset round up to even instead of rounding down
        
        Round suffers from the same hiccups thanks to floating-point representation error. When precision is paramount, you should use Python's Decimal module
  - - - series = pd.Series(np.random.randn(4))
        series.round(2)
        dataframe = pd.DataFrame(np.random.randn(3, 4), columns=["A", "B", "C"])
        dataframe.round(3)
        
        DataFrame.round() method can also accept a dictionary or Series, to specify a different precision for each column.
        
        dataframe.round({"A": 1, "B": 2, "C": 3})
        dataframe.round(pd.Series([1, 2, 3], index=["A", "B", "C"]))