Package org.python.core.util

# Class ExtraMath

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

public class ExtraMath extends Object
A static utility class with two additional math functions.

## Field Summary

Fields
Modifier and Type
Field
Description
`static double`
`CLOSE`
`static double`
`EPSILON`

## Constructor Summary

Constructors
Constructor
Description
`ExtraMath()`

## Method Summary

Modifier and Type
Method
Description
`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 Details

### EPSILON

public static double EPSILON

### CLOSE

public static double CLOSE

## Constructor Details

### ExtraMath

public ExtraMath()

## Method Details

### 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.