org.python.core.util

## Class ExtraMath

- java.lang.Object
- - org.python.core.util.ExtraMath

    public class ExtraMath
    extends java.lang.Object

A static utility class with two additional math functions.

### Field Summary

Fields
`static double` `CLOSE`
`static double` `EPSILON`

### Constructor Summary

Constructors
Constructor and Description
`ExtraMath()`

### Method Summary

All Methods Static Methods Concrete Methods
`static boolean` `close(double v, double w)`
`static boolean` `close(double v, double w, double tol)` Are v and w "close" to each other?
`static double` `closeFloor(double v)` Returns floor(v) except when v is very close to the next number, when it returns ceil(v);
`static double` `round(double x, int n)` Round the argument x to n decimal places.

### Methods inherited from class java.lang.Object

`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### EPSILON

    public static double EPSILON

#### CLOSE

    public static double CLOSE

### Constructor Detail

#### ExtraMath

    public ExtraMath()

### Method Detail

#### close

    public static boolean close(double v,
                                double w,
                                double tol)

Are v and w "close" to each other? Uses a scaled tolerance.

#### close

    public static boolean close(double v,
                                double w)

#### closeFloor

    public static double closeFloor(double v)

Returns floor(v) except when v is very close to the next number, when it returns ceil(v);

#### round

    public static double round(double x,
                               int n)

Round the argument x to n decimal places. (Rounding is half-up in Python 2.) The method uses BigDecimal, to compute r(x*10n)*10-n, where r() round to the nearest integer. It takes some short-cuts for extreme values.

For sufficiently small x*10n, the rounding is to zero, and the return value is a signed zero (same sign as x). Suppose x = a*2b, where the significand we must have a<2. Sufficiently small means such that n log210 < -(b+2).

For sufficiently large x*10n, the adjustment of rounding is too small to affect the least significant bit. That is a*2b represents an amount greater than one, and rounding no longer affects the value, and the return is x. Since the matissa has 52 fractional bits, sufficiently large means such that n log210 > 52-b.

Parameters:
  `x` - to round
  `n` - decimal places
Returns:
  x rounded.