N (Java Tool 1.26.2 API)

java.lang.Object
- org.osgl.util.N

Direct Known Subclasses:

NumberUtil, NumNS
```
public class N
extends Object
```
The namespace under which number relevant structures, functions and logics are defined.

Alias of NumberUtil

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`N._FloatRequire`
`static class`	`N._IntRequire`
`static class`	`N.ByteRangeStep`
`static class`	`N.Comparator`
`static class`	`N.Coordinate2D`
`static class`	`N.Dimension`
`static class`	`N.F`
`static class`	`N.IntRangeStep`
`static class`	`N.LongRangeStep`
`static class`	`N.Num<T extends Number>`
`static class`	`N.Op`
`static class`	`N.Pair`
`static class`	`N.RangeStep<T extends Number>`
`static class`	`N.ShortRangeStep`
`static class`	`N.Type`
`static class`	`N.WH`
`static class`	`N.XY`

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`E` The `double` value that is closer than any other to e, the base of the natural logarithms.
`static byte[]`	`EMPTY_BYTE_ARRAY` An empty `byte[]`
`static double[]`	`EMPTY_DOUBLE_ARRAY` An empty `double[]`
`static float[]`	`EMPTY_FLOAT_ARRAY` An empty `float[]`
`static int[]`	`EMPTY_INT_ARRAY` An empty `int[]`
`static long[]`	`EMPTY_LONG_ARRAY` An empty `long[]`
`static short[]`	`EMPTY_SHORT_ARRAY` An empty `short[]`
`static List<Class<? extends Number>>`	`NUMBER_CLASSES`
`static double`	`PI` The `double` value that is closer than any other to pi, the ratio of the circumference of a circle to its diameter.
`static int[]`	`POW_OF_TEN_INT`
`static long[]`	`POW_OF_TEN_LONG`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`abs(double a)`
`static float`	`abs(float a)`
`static int`	`abs(int a)`
`static long`	`abs(long a)`
`static double`	`cbrt(double a)`
`static double`	`ceil(double a)`
`static N.WH`	`dimension(int width, int height)`
`static boolean`	`eq(Number a, Number b)`
`static double`	`exp(double a)`
`static double`	`floor(double a)`
`static boolean`	`gt(Number a, Number b)`
`static boolean`	`isAlpha(double n)` Check if a double `d` is alpha - Image alpha float range is 0.0f to 1.0f inclusive.
`static boolean`	`isAlpha(float f)` Check if a float `f` is alpha - Image alpha float range is 0.0f to 1.0f inclusive.
`static boolean`	`isInt(String s)` Check if a string `s` represent an int or long
`static boolean`	`isInt(String s, int radix)` Check if a string `s` represent an int or long as per radix specified
`static boolean`	`isNegative(BigDecimal number)` Check if a `BigDecimal` is negative
`static boolean`	`isNegative(BigInteger number)` Check if a `BigInteger` is negative
`static boolean`	`isNumeric(String s)` Check if a String `s` is numeric string
`static boolean`	`isPerfectSquare(long n)` Check if a long is a perfect square number.
`static boolean`	`isPositive(BigDecimal number)` Check if a `BigDecimal` is positive
`static boolean`	`isPositive(BigInteger number)` Check if a `BigInteger` is positive
`static double`	`log(double a)`
`static double`	`log10(double a)`
`static boolean`	`lt(Number a, Number b)`
`static double`	`max(double a, double b)`
`static float`	`max(float a, float b)`
`static int`	`max(int a, int b)`
`static long`	`max(long a, long b)`
`static double`	`min(double a, double b)`
`static float`	`min(float a, float b)`
`static int`	`min(int a, int b)`
`static long`	`min(long a, long b)`
`static boolean`	`neq(Number a, Number b)`
`static N.Num`	`num(Number number)`
`static N.Num`	`num(String s)`
`static N.Pair`	`Pair(Integer a, Integer b)`
`static double`	`pow(double a, double b)`
`static int`	`powOfTen(int e)`
`static long`	`powOfTenLong(int e)`
`static double`	`randDouble()`
`static double`	`randDoubleWithSymbol()`
`static float`	`randFloat()`
`static float`	`randFloatWithSymbol()`
`static int`	`randInt()`
`static int`	`randInt(int max)`
`static int`	`randInt(int min, int max)`
`static int`	`randIntWithSymbol()`
`static int`	`randIntWithSymbol(int max)`
`static long`	`randLong()`
`static long`	`randLong(long max)`
`static long`	`randLongWithSymbol()`
`static N._IntRequire`	`require(int n)`
`static double`	`requireAlpha(double n)`
`static float`	`requireAlpha(float n)` Return a float value if it `isAlpha(float)` or raise an `IllegalArgumentException` if not.
`static float`	`requireAlpha(float n, String errorTemplate, Object... errorArgs)` Return a float value if it `isAlpha(float)` or raise an `IllegalArgumentException` with given error message specified if not.
`static double`	`requireNegative(double n)`
`static float`	`requireNegative(float n)`
`static int`	`requireNegative(int n)`
`static int`	`requireNegative(int n, String errorTemplate, Object... errorArgs)`
`static double`	`requireNonNegative(double n)`
`static float`	`requireNonNegative(float n)`
`static int`	`requireNonNegative(int n)`
`static int`	`requireNonNegative(int n, String errorTemplate, Object... errorArgs)`
`static double`	`requireNotNaN(double d)`
`static float`	`requireNotNaN(float f)`
`static double`	`requirePositive(double n)`
`static float`	`requirePositive(float n)` Return a positive float `n`.
`static float`	`requirePositive(float n, String errorTemplate, Object... errorArgs)` Return a positive float `n`.
`static int`	`requirePositive(int n)`
`static int`	`requirePositive(int n, String errorTemplate, Object... errorArgs)`
`static long`	`round(double a)`
`static double`	`round(double value, int places)`
`static int`	`round(float a)`
`static float`	`round(float value, int places)`
`static double`	`secureRandDouble()`
`static double`	`secureRandDoubleWithSymbol()`
`static float`	`secureRandFloat()`
`static float`	`secureRandFloatWithSymbol()`
`static int`	`secureRandInt()` The secure version of `randInt()`
`static int`	`secureRandInt(int max)`
`static int`	`secureRandInt(int min, int max)`
`static int`	`secureRandIntWithSymbol()`
`static int`	`secureRandIntWithSymbol(int max)`
`static long`	`secureRandLong()`
`static long`	`secureRandLongWithSymbol()`
`static int`	`sign(Number number)`
`static double`	`sqrt(double a)`
`static N.WH`	`wh(int w, int h)`
`static N.XY`	`xy(int x, int y)`

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

Field Detail
- EMPTY_BYTE_ARRAY
```
public static final byte[] EMPTY_BYTE_ARRAY
```
  An empty byte[]
- EMPTY_SHORT_ARRAY
```
public static final short[] EMPTY_SHORT_ARRAY
```
  An empty short[]
- EMPTY_INT_ARRAY
```
public static final int[] EMPTY_INT_ARRAY
```
  An empty int[]
- EMPTY_FLOAT_ARRAY
```
public static final float[] EMPTY_FLOAT_ARRAY
```
  An empty float[]
- EMPTY_LONG_ARRAY
```
public static final long[] EMPTY_LONG_ARRAY
```
  An empty long[]
- EMPTY_DOUBLE_ARRAY
```
public static final double[] EMPTY_DOUBLE_ARRAY
```
  An empty double[]
- POW_OF_TEN_INT
```
public static final int[] POW_OF_TEN_INT
```
- POW_OF_TEN_LONG
```
public static final long[] POW_OF_TEN_LONG
```
- E
```
public static final double E
```
  The double value that is closer than any other to e, the base of the natural logarithms.
  
  See Also:
  
  Constant Field Values
- PI
```
public static final double PI
```
  The double value that is closer than any other to pi, the ratio of the circumference of a circle to its diameter.
  
  See Also:
  
  Constant Field Values
- NUMBER_CLASSES
```
public static final List<Class<? extends Number>> NUMBER_CLASSES
```

Method Detail

Pair

public static N.Pair Pair(Integer a,
                          Integer b)

xy

public static N.XY xy(int x,
                      int y)

dimension

public static N.WH dimension(int width,
                             int height)

wh

public static N.WH wh(int w,
                      int h)

require

public static N._IntRequire require(int n)

requirePositive

public static int requirePositive(int n)

requirePositive

public static int requirePositive(int n,
                                  String errorTemplate,
                                  Object... errorArgs)

requireNonNegative

public static int requireNonNegative(int n)

requireNonNegative

public static int requireNonNegative(int n,
                                     String errorTemplate,
                                     Object... errorArgs)

requireNegative

public static int requireNegative(int n)

requireNegative

public static int requireNegative(int n,
                                  String errorTemplate,
                                  Object... errorArgs)

requirePositive
```
public static float requirePositive(float n)
```
Return a positive float n. If the passed in n is 0 or negative then it raised a IllegalArgumentException.

Parameters:

n - a float number.

Returns:

the number n if it is greater than 0.0f.

Throws:

IllegalArgumentException - if n is not greater than 0.0f.

requirePositive
```
public static float requirePositive(float n,
                                    String errorTemplate,
                                    Object... errorArgs)
```
Return a positive float n. If the passed in n is 0 or negative then it raised a IllegalArgumentException using the error template and arguments provided.

Parameters:

n - a float number.

errorTemplate - the error message template

errorArgs - the error message arguments

Returns:

the number n if it is greater than 0.0f.

Throws:

IllegalArgumentException - if n is not greater than 0.0f.

isAlpha
```
public static boolean isAlpha(float f)
```
Check if a float f is alpha - Image alpha float range is 0.0f to 1.0f inclusive.

Parameters:

f - the float number to be tested.

Returns:

true if f fall into alpha range or false otherwise

requireAlpha
```
public static float requireAlpha(float n)
```
Return a float value if it isAlpha(float) or raise an IllegalArgumentException if not.

Parameters:

n - the float number to be tested

Returns:

the float number if fall in image alpha float rage

Throws:

IllegalArgumentException - if the number is beyond the range

requireAlpha
```
public static float requireAlpha(float n,
                                 String errorTemplate,
                                 Object... errorArgs)
```
Return a float value if it isAlpha(float) or raise an IllegalArgumentException with given error message specified if not.

Parameters:

n - a float number.

errorTemplate - the error message template

errorArgs - the error message arguments

Returns:

the number n if it is greater than 0.0f.

Throws:

IllegalArgumentException - if n is not greater than 0.0f.

requireNotNaN

public static float requireNotNaN(float f)

requireNonNegative

public static float requireNonNegative(float n)

requireNegative

public static float requireNegative(float n)

isAlpha
```
public static boolean isAlpha(double n)
```
Check if a double d is alpha - Image alpha float range is 0.0f to 1.0f inclusive.

Parameters:

n - the float number to be tested.

Returns:

true if f fall into alpha range or false otherwise

requireAlpha

public static double requireAlpha(double n)

requirePositive

public static double requirePositive(double n)

requireNotNaN

public static double requireNotNaN(double d)

requireNonNegative

public static double requireNonNegative(double n)

requireNegative

public static double requireNegative(double n)

exp
```
public static double exp(double a)
```

log
```
public static double log(double a)
```

log10
```
public static double log10(double a)
```

sqrt
```
public static double sqrt(double a)
```

cbrt
```
public static double cbrt(double a)
```

ceil
```
public static double ceil(double a)
```

floor
```
public static double floor(double a)
```

pow

public static double pow(double a,
                         double b)

powOfTen
```
public static int powOfTen(int e)
```

powOfTenLong

public static long powOfTenLong(int e)

round
```
public static int round(float a)
```

round

public static float round(float value,
                          int places)

round
```
public static long round(double a)
```

round

public static double round(double value,
                           int places)

isPerfectSquare
```
public static final boolean isPerfectSquare(long n)
```
Check if a long is a perfect square number.

A perfect square number is an integer whose square root is also an integer

Parameters:

n - a number

Returns:

true if the number is perfect square number

See Also:

SO

isInt
```
public static boolean isInt(String s)
```
Check if a string s represent an int or long

Parameters:

s - the string

Returns:

true if s represents an int or false otherwise

isInt
```
public static boolean isInt(String s,
                            int radix)
```
Check if a string s represent an int or long as per radix specified

Parameters:

s - the string

radix - the radix

Returns:

true if s represents an int or false otherwise

isNumeric
```
public static boolean isNumeric(String s)
```
Check if a String s is numeric string

Parameters:

s - the string

Returns:

true if s is numeric or false otherwise

isNegative
```
public static boolean isNegative(BigDecimal number)
```
Check if a BigDecimal is negative

Parameters:

number - the number to be tested

Returns:

true if the number specified is negative or false otherwise

isNegative
```
public static boolean isNegative(BigInteger number)
```
Check if a BigInteger is negative

Parameters:

number - the number to be tested

Returns:

true if the number specified is negative or false otherwise

isPositive
```
public static boolean isPositive(BigDecimal number)
```
Check if a BigDecimal is positive

Parameters:

number - the number to be tested

Returns:

true if the number specified is positive or false otherwise

isPositive
```
public static boolean isPositive(BigInteger number)
```
Check if a BigInteger is positive

Parameters:

number - the number to be tested

Returns:

true if the number specified is positive or false otherwise

randInt
```
public static int randInt()
```
Returns:

a random int value

See Also:

Random.nextInt()

secureRandInt
```
public static int secureRandInt()
```
The secure version of randInt()

Returns:

randIntWithSymbol
```
public static int randIntWithSymbol()
```

secureRandIntWithSymbol

public static int secureRandIntWithSymbol()

randInt
```
public static int randInt(int max)
```
Parameters:

max - the max limit (exclusive) of the number generated

Returns:

a random int value

See Also:

Random.nextInt(int)

randInt

public static int randInt(int min,
                          int max)

secureRandInt

public static int secureRandInt(int max)

secureRandInt

public static int secureRandInt(int min,
                                int max)

randIntWithSymbol

public static int randIntWithSymbol(int max)

secureRandIntWithSymbol

public static int secureRandIntWithSymbol(int max)

randFloat
```
public static float randFloat()
```

secureRandFloat
```
public static float secureRandFloat()
```

randFloatWithSymbol

public static float randFloatWithSymbol()

secureRandFloatWithSymbol

public static float secureRandFloatWithSymbol()

randLong
```
public static long randLong()
```

randLong

public static long randLong(long max)

secureRandLong
```
public static long secureRandLong()
```

randLongWithSymbol

public static long randLongWithSymbol()

secureRandLongWithSymbol

public static long secureRandLongWithSymbol()

randDouble
```
public static double randDouble()
```
Returns:

a random double value

See Also:

Random.nextDouble()

secureRandDouble

public static double secureRandDouble()

randDoubleWithSymbol

public static double randDoubleWithSymbol()

secureRandDoubleWithSymbol

public static double secureRandDoubleWithSymbol()

abs
```
public static int abs(int a)
```

abs
```
public static long abs(long a)
```

abs
```
public static float abs(float a)
```

abs
```
public static double abs(double a)
```

max

public static int max(int a,
                      int b)

max

public static long max(long a,
                       long b)

max

public static float max(float a,
                        float b)

max

public static double max(double a,
                         double b)

min

public static int min(int a,
                      int b)

min

public static long min(long a,
                       long b)

min

public static float min(float a,
                        float b)

min

public static double min(double a,
                         double b)

sign

public static int sign(Number number)

eq

public static final boolean eq(Number a,
                               Number b)

neq

public static final boolean neq(Number a,
                                Number b)

lt

public static final boolean lt(Number a,
                               Number b)

gt

public static final boolean gt(Number a,
                               Number b)

num

public static final N.Num num(Number number)

num

public static final N.Num num(String s)

Class N

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EMPTY_BYTE_ARRAY

EMPTY_SHORT_ARRAY

EMPTY_INT_ARRAY

EMPTY_FLOAT_ARRAY

EMPTY_LONG_ARRAY

EMPTY_DOUBLE_ARRAY

POW_OF_TEN_INT

POW_OF_TEN_LONG

E

PI

NUMBER_CLASSES

Method Detail

Pair

xy

dimension

wh

require

requirePositive

requirePositive

requireNonNegative

requireNonNegative

requireNegative

requireNegative

requirePositive

requirePositive

isAlpha

requireAlpha

requireAlpha

requireNotNaN

requireNonNegative

requireNegative

isAlpha

requireAlpha

requirePositive

requireNotNaN

requireNonNegative

requireNegative

exp

log

log10

sqrt

cbrt

ceil

floor

pow

powOfTen

powOfTenLong

round

round

round

round

isPerfectSquare

isInt

isInt

isNumeric

isNegative

isNegative

isPositive

isPositive

randInt

secureRandInt

randIntWithSymbol

secureRandIntWithSymbol

randInt

randInt

secureRandInt

secureRandInt

randIntWithSymbol

secureRandIntWithSymbol

randFloat

secureRandFloat

randFloatWithSymbol

secureRandFloatWithSymbol

randLong