Package: java.lang

## Class Number

- - ### Methods Summary

    Methods
    Return type | Name and parameters
    --- | ---
    `int` | `abs()` Get the absolute value
    `Number` | `and(Number right)` Bitwise AND together two Numbers.
    `boolean` | `asBoolean()` Coerce a number to a boolean value.
    `Object` | `asType(Class c)` Transform this number to the given type, using the 'as' operator.
    `Number` | `bitwiseNegate()` Bitwise NEGATE a Number.
    `int` | `compareTo(Character right)` Compare a Number and a Character.
    `int` | `compareTo(Number right)` Compare two Numbers.
    `Number` | `div(Character right)` Divide a Number by a Character.
    `Number` | `div(Number right)` Divide two Numbers.
    `void` | `downto(Number to, Closure closure)` Iterates from this number down to the given number, inclusive, decrementing by one each time.
    `Number` | `intdiv(Character right)` Integer Divide a Number by a Character.
    `Number` | `intdiv(Number right)` Integer Divide two Numbers.
    `boolean` | `isCase(Number switchValue)` Special 'case' implementation for all numbers, which delegates to the `compareTo()` method for comparing numbers of different types.
    `boolean` | `isNotCase(Number switchValue)`
    `Number` | `leftShift(Number operand)` Implementation of the left shift operator for integral types.
    `Number` | `minus(Character right)` Subtract a Character from a Number.
    `Number` | `minus(Number right)` Subtraction of two Numbers.
    `Number` | `mod(Number right)` Performs a division modulus operation.
    `Number` | `multiply(Character right)` Multiply a Number by a Character.
    `Number` | `multiply(Number right)` Multiply two Numbers.
    `Number` | `next()` Increment a Number by one.
    `Number` | `or(Number right)` Bitwise OR together two numbers.
    `Number` | `plus(Character right)` Add a Number and a Character.
    `Number` | `plus(Number right)` Add two numbers and return the result.
    `String` | `plus(String right)` Appends a String to the string representation of this number.
    `Number` | `power(Number exponent)` Power of a Number to a certain exponent.
    `Number` | `previous()` Decrement a Number by one.
    `Number` | `rightShift(Number operand)` Implementation of the right shift operator for integral types.
    `Number` | `rightShiftUnsigned(Number operand)` Implementation of the right shift (unsigned) operator for integral types.
    `void` | `step(Number to, Number stepNumber, Closure closure)` Iterates from this number up to the given number using a step increment.
    `void` | `times(Closure closure)` Executes the closure this many times, starting from zero.
    `BigDecimal` | `toBigDecimal()` Transform a Number into a BigDecimal
    `BigInteger` | `toBigInteger()` Transform this Number into a BigInteger.
    `Double` | `toDouble()` Transform a Number into a Double
    `Float` | `toFloat()` Transform a Number into a Float
    `Integer` | `toInteger()` Transform a Number into an Integer
    `Long` | `toLong()` Transform a Number into a Long
    `Number` | `unaryMinus()` Negates the number.
    `Number` | `unaryPlus()` Returns the number, effectively being a noop for numbers.
    `void` | `upto(Number to, Closure closure)` Iterates from this number up to the given number, inclusive, incrementing by one each time.
    `Number` | `xor(Number right)` Bitwise XOR together two Numbers.

  - #### Methods inherited from class java.lang.Object

    `addShutdownHook`, `any`, `any`, `asBoolean`, `asType`, `collect`, `collect`, `collect`, `dump`, `each`, `eachMatch`, `eachMatch`, `eachWithIndex`, `every`, `every`, `find`, `find`, `findAll`, `findAll`, `findIndexOf`, `findIndexOf`, `findIndexValues`, `findIndexValues`, `findLastIndexOf`, `findLastIndexOf`, `findResult`, `findResult`, `findResult`, `findResult`, `getAt`, `getMetaClass`, `getMetaPropertyValues`, `getProperties`, `grep`, `grep`, `hasProperty`, `identity`, `inject`, `inject`, `inspect`, `invokeMethod`, `is`, `isCase`, `isNotCase`, `iterator`, `metaClass`, `print`, `print`, `printf`, `printf`, `println`, `println`, `println`, `putAt`, `respondsTo`, `respondsTo`, `setMetaClass`, `split`, `sprintf`, `sprintf`, `stream`, `tap`, `toString`, `use`, `use`, `use`, `with`, `with`, `withCloseable`, `withStream`, `withTraits`

- - ### Methods Detail

    - #### public int abs()

      Get the absolute value

      Returns:
        the absolute value of that Number
      Since:
        1.0

    - #### public Number and(Number right)

      Bitwise AND together two Numbers.

      Parameters:
        `right` - another Number to bitwise AND
      Returns:
        the bitwise AND of both Numbers
      Since:
        1.0

    - #### public boolean asBoolean()

      Coerce a number to a boolean value. A number is coerced to false if its double value is equal to 0, and to true otherwise.

      Returns:
        the boolean value
      Since:
        1.7.0

    - #### public Object asType(Class c)

      Transform this number to the given type, using the 'as' operator. The following types are supported in addition to the default Object#asType(java.lang.Class):

      - BigDecimal
      - BigInteger
      - Double
      - Float
      Parameters:
        `c` - the desired type of the transformed result
      Returns:
        an instance of the given type
      Since:
        1.0

    - #### public Number bitwiseNegate()

      Bitwise NEGATE a Number.

      Returns:
        the bitwise NEGATE of the Number
      Since:
        2.2.0

    - #### public int compareTo(Character right)

      Compare a Number and a Character. The ordinal value of the Character is used in the comparison (the ordinal value is the unicode value which for simple character sets is the ASCII value).

      Parameters:
        `right` - a Character
      Returns:
        the result of the comparison
      Since:
        1.0

    - #### public int compareTo(Number right)

      Compare two Numbers. Equality (==) for numbers dispatches to this.

      Parameters:
        `right` - another Number to compare to
      Returns:
        the comparison of both numbers
      Since:
        1.0

    - #### public Number div(Character right)

      Divide a Number by a Character. The ordinal value of the Character is used in the division (the ordinal value is the unicode value which for simple character sets is the ASCII value).

      Parameters:
        `right` - a Character
      Returns:
        the Number corresponding to the division of left by right
      Since:
        1.0

    - #### public Number div(Number right)

      Divide two Numbers. Note: Method name different from 'divide' to avoid collision with BigInteger method that has different semantics. We want a BigDecimal result rather than a BigInteger.

      Parameters:
        `right` - another Number
      Returns:
        a Number resulting of the divide operation

    - #### public void downto(Number to, Closure closure)

      Iterates from this number down to the given number, inclusive, decrementing by one each time.

      Parameters:
        `to` - another Number to go down to
        `closure` - the closure to call
      Since:
        1.0

    - #### public Number intdiv(Character right)

      Integer Divide a Number by a Character. The ordinal value of the Character is used in the division (the ordinal value is the unicode value which for simple character sets is the ASCII value).

      Parameters:
        `right` - a Character
      Returns:
        a Number (an Integer) resulting from the integer division operation
      Since:
        1.0

    - #### public Number intdiv(Number right)

      Integer Divide two Numbers.

      Parameters:
        `right` - another Number
      Returns:
        a Number (an Integer) resulting from the integer division operation
      Since:
        1.0

    - #### public boolean isCase(Number switchValue)

      Special 'case' implementation for all numbers, which delegates to the `compareTo()` method for comparing numbers of different types.

      Parameters:
        `switchValue` - the switch value
      Returns:
        true if the numbers are deemed equal
      Since:
        1.5.0

    - #### public boolean isNotCase(Number switchValue)

      Parameters:
      Since:
        4.0.0

    - #### public Number leftShift(Number operand)

      Implementation of the left shift operator for integral types. Non-integral Number types throw UnsupportedOperationException.

      Parameters:
        `operand` - the shift distance by which to left shift the number
      Returns:
        the resulting number
      Since:
        1.5.0

    - #### public Number minus(Character right)

      Subtract a Character from a Number. The ordinal value of the Character is used in the subtraction (the ordinal value is the unicode value which for simple character sets is the ASCII value).

      Parameters:
        `right` - a Character
      Returns:
        the Number corresponding to the subtraction of right from left
      Since:
        1.0

    - #### public Number minus(Number right)

      Subtraction of two Numbers.

      Parameters:
        `right` - another Number to subtract to the first one
      Returns:
        the subtraction

    - #### public Number mod(Number right)

      Performs a division modulus operation. Called by the '%' operator.

      Parameters:
        `right` - another Number to mod
      Returns:
        the modulus result
      Since:
        1.0

    - #### public Number multiply(Character right)

      Multiply a Number by a Character. The ordinal value of the Character is used in the multiplication (the ordinal value is the unicode value which for simple character sets is the ASCII value).

      Parameters:
        `right` - a Character
      Returns:
        the multiplication of left by right
      Since:
        1.0

    - #### public Number multiply(Number right)

      Multiply two Numbers.

      Parameters:
        `right` - another Number
      Returns:
        the multiplication of both

    - #### public Number next()

      Increment a Number by one.

      Returns:
        an incremented Number
      Since:
        1.0

    - #### public Number or(Number right)

      Bitwise OR together two numbers.

      Parameters:
        `right` - another Number to bitwise OR
      Returns:
        the bitwise OR of both Numbers
      Since:
        1.0

    - #### public Number plus(Character right)

      Add a Number and a Character. The ordinal value of the Character is used in the addition (the ordinal value is the unicode value which for simple character sets is the ASCII value).

      Parameters:
        `right` - a Character
      Returns:
        The Number corresponding to the addition of left and right
      Since:
        1.0
      See Also:
        Integer#valueOf(int)

    - #### public Number plus(Number right)

      Add two numbers and return the result.

      Parameters:
        `right` - another Number to add
      Returns:
        the addition of both Numbers

    - #### public String plus(String right)

      Appends a String to the string representation of this number.

      Parameters:
        `right` - a String
      Returns:
        a String
      Since:
        1.0

    - #### public Number power(Number exponent)

      Power of a Number to a certain exponent. Called by the '**' operator.

      Parameters:
        `exponent` - a Number exponent
      Returns:
        a Number to the power of a certain exponent
      Since:
        1.0

    - #### public Number previous()

      Decrement a Number by one.

      Returns:
        a decremented Number
      Since:
        1.0

    - #### public Number rightShift(Number operand)

      Implementation of the right shift operator for integral types. Non-integral Number types throw UnsupportedOperationException.

      Parameters:
        `operand` - the shift distance by which to right shift the number
      Returns:
        the resulting number
      Since:
        1.5.0

    - #### public Number rightShiftUnsigned(Number operand)

      Implementation of the right shift (unsigned) operator for integral types. Non-integral Number types throw UnsupportedOperationException.

      Parameters:
        `operand` - the shift distance by which to right shift (unsigned) the number
      Returns:
        the resulting number
      Since:
        1.5.0

    - #### public void step(Number to, Number stepNumber, Closure closure)

      Iterates from this number up to the given number using a step increment. Each intermediate number is passed to the given closure. Example:

          0.step( 10, 2 ) {
            println it
          }

      Prints even numbers 0 through 8.
      Parameters:
        `to` - a Number to go up to, exclusive
        `stepNumber` - a Number representing the step increment
        `closure` - the closure to call
      Since:
        1.0

    - #### public void times(Closure closure)

      Executes the closure this many times, starting from zero. The current index is passed to the closure each time. Example:

          10.times {
            println it
          }

      Prints the numbers 0 through 9.
      Parameters:
        `closure` - the closure to call a number of times
      Since:
        1.0

    - #### public BigDecimal toBigDecimal()

      Transform a Number into a BigDecimal

      Returns:
        a BigDecimal
      Since:
        1.0

    - #### public BigInteger toBigInteger()

      Transform this Number into a BigInteger.

      Returns:
        a BigInteger
      Since:
        1.0

    - #### public Double toDouble()

      Transform a Number into a Double

      Returns:
        a Double
      Since:
        1.0

    - #### public Float toFloat()

      Transform a Number into a Float

      Returns:
        a Float
      Since:
        1.0

    - #### public Integer toInteger()

      Transform a Number into an Integer

      Returns:
        an Integer
      Since:
        1.0

    - #### public Long toLong()

      Transform a Number into a Long

      Returns:
        a Long
      Since:
        1.0

    - #### public Number unaryMinus()

      Negates the number. Equivalent to the '-' operator when it precedes a single operand, i.e. `-10`

      Returns:
        the negation of the number
      Since:
        1.5.0

    - #### public Number unaryPlus()

      Returns the number, effectively being a noop for numbers. Operator overloaded form of the '+' operator when it precedes a single operand, i.e. `+10`

      Returns:
        the number
      Since:
        2.2.0

    - #### public void upto(Number to, Closure closure)

      Iterates from this number up to the given number, inclusive, incrementing by one each time.

      Parameters:
        `to` - another Number to go up to
        `closure` - the closure to call
      Since:
        1.0

    - #### public Number xor(Number right)

      Bitwise XOR together two Numbers. Called when the '^' operator is used.

      Parameters:
        `right` - another Number to bitwise XOR
      Returns:
        the bitwise XOR of both Numbers
      Since:
        1.0