Maths (OpenHFT/Chronicle-Core 2.20ea127 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 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(@NotNull 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)`
`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 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 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, @NotNull 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
  - 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
  - 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
                         @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(@NotNull
                          @NotNull 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)
```
    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
                          @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)
```
  - 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)
```

Enum Maths

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Method Detail

values

valueOf

roundN

roundingFactor

roundingFactor

ceilN

floorN

roundN

ceilN

floorN

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

digits

fives

same

same

hash

hash

hash

hash

hash