Maths (OpenHFT/Chronicle-Core 1.9.0 API)

java.lang.Object
- java.lang.Enum<Maths>
- - net.openhft.chronicle.core.Maths

All Implemented Interfaces:

Serializable, Comparable<Maths>
```
public enum Maths
extends Enum<Maths>
```

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static long`	`agitate(long l)`
`static long`	`divideRoundUp(long dividend, long divisor)` Divide `dividend` by divisor, if division is not integral the result is rounded up.
`static int`	`hash32(CharSequence cs)`
`static int`	`hash32(long l0)`
`static int`	`hash32(String s)`
`static int`	`hash32(StringBuilder s)`
`static long`	`hash64(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(String s)`
`static long`	`hash64(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)`
`static long`	`nextPower2(long n, long min)`
`static double`	`round1(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`	`round3(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`	`round5(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`	`round7(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`	`roundN(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 x)`
`static int`	`toInt32(long x)`
`static int`	`toInt32(long x, String msg)`
`static byte`	`toInt8(long x)`
`static int`	`toUInt16(long x)`
`static int`	`toUInt31(long x)`
`static long`	`toUInt32(long x)`
`static short`	`toUInt8(long x)`
`static Maths`	`valueOf(String name)` Returns the enum constant of this type with the specified name.
`static Maths[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Method Detail
  - values
```
public static Maths[] values()
```
    Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
```
for (Maths c : Maths.values())
    System.out.println(c);
```
    Returns:
    
    an array containing the constants of this enum type, in the order they are declared
  - valueOf
```
public static Maths valueOf(String name)
```
    Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
    
    Parameters:
    
    name - the name of the enum constant to be returned.
    
    Returns:
    
    the enum constant with the specified name
    
    Throws:
    
    IllegalArgumentException - if this enum type has no constant with the specified name
    
    NullPointerException - if the argument is null
  - 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
  - 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
  - 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
  - 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
  - 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
  - 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
  - round6
```
public static double round6(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
  - 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
  - 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
  - nextPower2
```
public static int nextPower2(int n,
                             int min)
                      throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - nextPower2
```
public static long nextPower2(long n,
                              long min)
                       throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - isPowerOf2
```
public static boolean isPowerOf2(long n)
```
  - hash32
```
public static int hash32(@NotNull
                         CharSequence cs)
```
  - hash32
```
public static int hash32(@NotNull
                         String s)
```
  - hash32
```
public static int hash32(@NotNull
                         StringBuilder s)
```
  - hash32
```
public static int hash32(long l0)
```
  - hash64
```
public static long hash64(@NotNull
                          CharSequence cs)
```
  - hash64
```
public static long hash64(@NotNull
                          String s)
```
  - hash64
```
public static long hash64(@NotNull
                          StringBuilder s)
```
  - intLog2
```
public static int intLog2(long num)
```
    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 x)
                   throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - toInt16
```
public static short toInt16(long x)
                     throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - toInt32
```
public static int toInt32(long x,
                          @NotNull
                          String msg)
                   throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - toInt32
```
public static int toInt32(long x)
                   throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - toUInt8
```
public static short toUInt8(long x)
                     throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - toUInt16
```
public static int toUInt16(long x)
                    throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - toUInt31
```
public static int toUInt31(long x)
                    throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - toUInt32
```
public static long toUInt32(long x)
                     throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - 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)
```
  - same
```
public static boolean same(double a,
                           double b)
```
  - same
```
public static boolean same(float a,
                           float b)
```

Enum Maths

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Method Detail

values

valueOf

roundN

round1

round2

round3

round4

round5

round6

round7

round8

nextPower2

nextPower2

isPowerOf2

hash32

hash32

hash32

hash32

hash64

hash64

hash64

intLog2

toInt8

toInt16

toInt32

toInt32

toUInt8

toUInt16

toUInt31

toUInt32

agitate

hash64

hash64

divideRoundUp

tens

same

same