Maths (OpenHFT/Chronicle-Core 2.23ea13 API)

java.lang.Object
- net.openhft.chronicle.core.Maths

```
public final class Maths
extends Object
```

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static long`	`agitate(long l)`
`static double`	`ceilN(double d, double digits)`
`static double`	`ceilN(double d, int digits)`
`static int`	`digits(long num)`
`static long`	`divideRoundUp(long dividend, long divisor)` Divide `dividend` by divisor, if division is not integral the result is rounded up.
`static long`	`fives(int decimalPlaces)`
`static double`	`floorN(double d, double digits)`
`static double`	`floorN(double d, int digits)`
`static int`	`hash(Object o)`
`static int`	`hash(Object o1, Object o2)`
`static int`	`hash(Object o1, Object o2, Object o3)`
`static int`	`hash(Object o1, Object o2, Object o3, Object o4)`
`static int`	`hash(Object o1, Object o2, Object o3, Object o4, Object o5)`
`static int`	`hash32(@NotNull CharSequence cs)`
`static int`	`hash32(long l0)`
`static int`	`hash32(@NotNull String s)`
`static int`	`hash32(@NotNull StringBuilder s)`
`static long`	`hash64(@Nullable CharSequence cs)`
`static long`	`hash64(long l0)` A simple hashing algorithm for a 64-bit value
`static long`	`hash64(long l0, long l1)` A simple hashing algorithm for a 128-bit value
`static long`	`hash64(@NotNull String s)`
`static long`	`hash64(@NotNull StringBuilder s)`
`static int`	`intLog2(long num)` Returns rounded down log₂`num`, e.
`static boolean`	`isPowerOf2(long n)`
`static int`	`nextPower2(int n, int min)` Returns the next power of two.
`static long`	`nextPower2(long n, long min)` Returns the next power of two.
`static double`	`round1(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round1up(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round2(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round2up(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round3(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round3up(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round4(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round4up(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round5(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round5up(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round6(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round6up(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round7(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round7up(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round8(double d)` Performs a round which is accurate to within 1 ulp.
`static double`	`round8up(double d)` Performs a round which is accurate to within 1 ulp.
`static long`	`roundingFactor(double digits)`
`static long`	`roundingFactor(int digits)`
`static double`	`roundN(double d, double digits)`
`static double`	`roundN(double d, int digits)` Performs a round which is accurate to within 1 ulp.
`static double`	`roundNup(double d, int digits)` Performs a round which is accurate to within 1 ulp.
`static boolean`	`same(double a, double b)`
`static boolean`	`same(float a, float b)`
`static long`	`tens(int decimalPlaces)`
`static short`	`toInt16(long value)` Returns the value of the `long` argument; throwing an exception if the value overflows a `short`.
`static int`	`toInt32(long value)` Returns the value of the `long` argument; throwing an exception if the value overflows an `int`.
`static int`	`toInt32(long value, @NotNull String msg)` Returns the value of the `long` argument; throwing an exception if the value overflows an `int`.
`static byte`	`toInt8(long value)` Returns the value of the `long` argument; throwing an exception if the value overflows a `byte`.
`static int`	`toUInt16(long value)` Returns the value of the `long` argument; throwing an exception if the value overflows an unsigned short (0xFFFF).
`static int`	`toUInt31(long value)` Returns the value of the `long` argument; throwing an exception if the value overflows an unsigned 31 bit value (0x7FFFFFFFL).
`static long`	`toUInt32(long value)` Returns the value of the `long` argument; throwing an exception if the value overflows an unsigned int (0xFFFFFFFFL).
`static short`	`toUInt8(long value)` Returns the value of the `long` argument; throwing an exception if the value overflows an unsigned byte (0xFF).

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - roundN
```
public static double roundN(double d,
                            int digits)
```
    Performs a round which is accurate to within 1 ulp. i.e. for values very close to 0.5 it might be rounded up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    digits - 0 to 18 digits of precision
    
    Returns:
    
    rounded value
  - roundNup
```
public static double roundNup(double d,
                              int digits)
```
    Performs a round which is accurate to within 1 ulp. The value 0.5 should round up however the value one ulp less might round up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - roundingFactor
```
public static long roundingFactor(int digits)
```
  - roundingFactor
```
public static long roundingFactor(double digits)
```
  - ceilN
```
public static double ceilN(double d,
                           int digits)
```
  - floorN
```
public static double floorN(double d,
                            int digits)
```
  - roundN
```
public static double roundN(double d,
                            double digits)
```
  - ceilN
```
public static double ceilN(double d,
                           double digits)
```
  - floorN
```
public static double floorN(double d,
                            double digits)
```
  - round1
```
public static double round1(double d)
```
    Performs a round which is accurate to within 1 ulp. i.e. for values very close to 0.5 it might be rounded up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round1up
```
public static double round1up(double d)
```
    Performs a round which is accurate to within 1 ulp. The value 0.5 should round up however the value one ulp less might round up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round2
```
public static double round2(double d)
```
    Performs a round which is accurate to within 1 ulp. i.e. for values very close to 0.5 it might be rounded up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round2up
```
public static double round2up(double d)
```
    Performs a round which is accurate to within 1 ulp. The value 0.5 should round up however the value one ulp less might round up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round3
```
public static double round3(double d)
```
    Performs a round which is accurate to within 1 ulp. i.e. for values very close to 0.5 it might be rounded up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round3up
```
public static double round3up(double d)
```
    Performs a round which is accurate to within 1 ulp. The value 0.5 should round up however the value one ulp less might round up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round4
```
public static double round4(double d)
```
    Performs a round which is accurate to within 1 ulp. i.e. for values very close to 0.5 it might be rounded up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round4up
```
public static double round4up(double d)
```
    Performs a round which is accurate to within 1 ulp. The value 0.5 should round up however the value one ulp less might round up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round5
```
public static double round5(double d)
```
    Performs a round which is accurate to within 1 ulp. i.e. for values very close to 0.5 it might be rounded up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round5up
```
public static double round5up(double d)
```
    Performs a round which is accurate to within 1 ulp. The value 0.5 should round up however the value one ulp less might round up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round6
```
public static double round6(double d)
```
    Performs a round which is accurate to within 1 ulp. The value 0.5 should round up however the value one ulp less might round up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round6up
```
public static double round6up(double d)
```
    Performs a round which is accurate to within 1 ulp. The value 0.5 should round up however the value one ulp less might round up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round7
```
public static double round7(double d)
```
    Performs a round which is accurate to within 1 ulp. i.e. for values very close to 0.5 it might be rounded up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round7up
```
public static double round7up(double d)
```
    Performs a round which is accurate to within 1 ulp. The value 0.5 should round up however the value one ulp less might round up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round8
```
public static double round8(double d)
```
    Performs a round which is accurate to within 1 ulp. i.e. for values very close to 0.5 it might be rounded up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - round8up
```
public static double round8up(double d)
```
    Performs a round which is accurate to within 1 ulp. The value 0.5 should round up however the value one ulp less might round up or down. This is a pragmatic choice for performance reasons as it is assumed you are not working on the edge of the precision of double.
    
    Parameters:
    
    d - value to round
    
    Returns:
    
    rounded value
  - nextPower2
```
public static int nextPower2(int n,
                             int min)
                      throws IllegalArgumentException
```
    Returns the next power of two.
    
    Parameters:
    
    n - to find the next power of two from
    
    min - if n < min then use min
    
    Returns:
    
    the next power of two
    
    Throws:
    
    IllegalArgumentException - if the provided min value is not a power of two.
  - nextPower2
```
public static long nextPower2(long n,
                              long min)
                       throws IllegalArgumentException
```
    Returns the next power of two.
    
    Parameters:
    
    n - to find the next power of two from
    
    min - if n < min then use min
    
    Returns:
    
    the next power of two
    
    Throws:
    
    IllegalArgumentException - if the provided min value is not a power of two.
  - isPowerOf2
```
public static boolean isPowerOf2(long n)
```
  - hash32
```
public static int hash32(@NotNull
                         @NotNull CharSequence cs)
```
  - hash32
```
public static int hash32(@NotNull
                         @NotNull String s)
```
  - hash32
```
public static int hash32(@NotNull
                         @NotNull StringBuilder s)
```
  - hash32
```
public static int hash32(long l0)
```
  - hash64
```
public static long hash64(@Nullable
                          @Nullable CharSequence cs)
```
  - hash64
```
public static long hash64(@NotNull
                          @NotNull String s)
```
  - hash64
```
public static long hash64(@NotNull
                          @NotNull StringBuilder s)
```
  - intLog2
```
public static int intLog2(long num)
                   throws IllegalArgumentException
```
    Returns rounded down log₂num, e. g.: intLog2(1) == 0, intLog2(2) == 1, intLog2(7) == 2, intLog2(8) == 3, etc.
    
    Throws:
    
    IllegalArgumentException - if the given number <= 0
  - toInt8
```
public static byte toInt8(long value)
                   throws ArithmeticException
```
    Returns the value of the long argument; throwing an exception if the value overflows a byte.
    
    Parameters:
    
    value - the long value
    
    Returns:
    
    the argument as a byte
    
    Throws:
    
    ArithmeticException - if the argument overflows a byte
  - toInt16
```
public static short toInt16(long value)
                     throws ArithmeticException
```
    Returns the value of the long argument; throwing an exception if the value overflows a short.
    
    Parameters:
    
    value - the long value
    
    Returns:
    
    the argument as a short
    
    Throws:
    
    ArithmeticException - if the argument overflows a short
  - toInt32
```
public static int toInt32(long value,
                          @NotNull
                          @NotNull String msg)
                   throws ArithmeticException
```
    Returns the value of the long argument; throwing an exception if the value overflows an int.
    
    Parameters:
    
    value - the long value
    
    msg - to use in a potential exception message
    
    Returns:
    
    the argument as an int
    
    Throws:
    
    ArithmeticException - if the argument overflows an int
  - toInt32
```
public static int toInt32(long value)
                   throws ArithmeticException
```
    Returns the value of the long argument; throwing an exception if the value overflows an int.
    
    Parameters:
    
    value - the long value
    
    Returns:
    
    the argument as an int
    
    Throws:
    
    ArithmeticException - if the argument overflows an int
  - toUInt8
```
public static short toUInt8(long value)
                     throws ArithmeticException
```
    Returns the value of the long argument; throwing an exception if the value overflows an unsigned byte (0xFF).
    
    Parameters:
    
    value - the long value
    
    Returns:
    
    the argument as a short
    
    Throws:
    
    ArithmeticException - if the argument overflows an unsigned byte
  - toUInt16
```
public static int toUInt16(long value)
                    throws ArithmeticException
```
    Returns the value of the long argument; throwing an exception if the value overflows an unsigned short (0xFFFF).
    
    Parameters:
    
    value - the long value
    
    Returns:
    
    the argument as an int
    
    Throws:
    
    ArithmeticException - if the argument overflows an unsigned short
  - toUInt31
```
public static int toUInt31(long value)
                    throws ArithmeticException
```
    Returns the value of the long argument; throwing an exception if the value overflows an unsigned 31 bit value (0x7FFFFFFFL).
    
    Parameters:
    
    value - the long value
    
    Returns:
    
    the argument as a long
    
    Throws:
    
    ArithmeticException - if the argument overflows an unsigned int
  - toUInt32
```
public static long toUInt32(long value)
                     throws ArithmeticException
```
    Returns the value of the long argument; throwing an exception if the value overflows an unsigned int (0xFFFFFFFFL).
    
    Parameters:
    
    value - the long value
    
    Returns:
    
    the argument as a long
    
    Throws:
    
    ArithmeticException - if the argument overflows an unsigned int
  - agitate
```
public static long agitate(long l)
```
  - hash64
```
public static long hash64(long l0)
```
    A simple hashing algorithm for a 64-bit value
    
    Parameters:
    
    l0 - to hash
    
    Returns:
    
    hash value.
  - hash64
```
public static long hash64(long l0,
                          long l1)
```
    A simple hashing algorithm for a 128-bit value
    
    Parameters:
    
    l0 - to hash
    
    l1 - to hash
    
    Returns:
    
    hash value.
  - divideRoundUp
```
public static long divideRoundUp(long dividend,
                                 long divisor)
```
    Divide dividend by divisor, if division is not integral the result is rounded up. Examples: divideRoundUp(10, 5) == 2, divideRoundUp(11, 5) == 3, divideRoundUp(-10, 5) == -2, divideRoundUp(-11, 5) == -3.
    
    Returns:
    
    the rounded up quotient
  - tens
```
public static long tens(int decimalPlaces)
```
  - digits
```
public static int digits(long num)
```
  - fives
```
public static long fives(int decimalPlaces)
```
  - same
```
public static boolean same(double a,
                           double b)
```
  - same
```
public static boolean same(float a,
                           float b)
```
  - hash
```
public static int hash(Object o)
```
  - hash
```
public static int hash(Object o1,
                       Object o2)
```
  - hash
```
public static int hash(Object o1,
                       Object o2,
                       Object o3)
```
  - hash
```
public static int hash(Object o1,
                       Object o2,
                       Object o3,
                       Object o4)
```
  - hash
```
public static int hash(Object o1,
                       Object o2,
                       Object o3,
                       Object o4,
                       Object o5)
```

Class Maths

Method Summary

Methods inherited from class java.lang.Object

Method Detail

roundN

roundNup

roundingFactor

roundingFactor

ceilN

floorN

roundN

ceilN

floorN

round1

round1up

round2

round2up

round3

round3up

round4

round4up

round5

round5up

round6

round6up

round7

round7up

round8

round8up

nextPower2

nextPower2

isPowerOf2

hash32

hash32

hash32

hash32

hash64

hash64

hash64

intLog2

toInt8

toInt16

toInt32

toInt32

toUInt8

toUInt16

toUInt31

toUInt32

agitate

hash64

hash64

divideRoundUp

tens

digits

fives

same

same

hash

hash

hash

hash

hash