Package: org.codehaus.groovy.runtime.typehandling

## [Java] Class NumberMathModificationInfo

- org.codehaus.groovy.runtime.typehandling.NumberMathModificationInfo

- - ### Field Summary

    Fields
    Modifiers | Name | Description
    --- | --- | ---
    `boolean` | `byte_and` |
    `boolean` | `byte_div` |
    `boolean` | `byte_intdiv` |
    `boolean` | `byte_leftShift` |
    `boolean` | `byte_minus` |
    `boolean` | `byte_mod` |
    `boolean` | `byte_multiply` |
    `boolean` | `byte_or` |
    `boolean` | `byte_plus` |
    `boolean` | `byte_rightShift` |
    `boolean` | `byte_rightShiftUnsigned` |
    `boolean` | `byte_xor` |
    `boolean` | `double_and` |
    `boolean` | `double_div` |
    `boolean` | `double_intdiv` |
    `boolean` | `double_leftShift` |
    `boolean` | `double_minus` |
    `boolean` | `double_mod` |
    `boolean` | `double_multiply` |
    `boolean` | `double_or` |
    `boolean` | `double_plus` |
    `boolean` | `double_rightShift` |
    `boolean` | `double_rightShiftUnsigned` |
    `boolean` | `double_xor` |
    `boolean` | `float_and` |
    `boolean` | `float_div` |
    `boolean` | `float_intdiv` |
    `boolean` | `float_leftShift` |
    `boolean` | `float_minus` |
    `boolean` | `float_mod` |
    `boolean` | `float_multiply` |
    `boolean` | `float_or` |
    `boolean` | `float_plus` |
    `boolean` | `float_rightShift` |
    `boolean` | `float_rightShiftUnsigned` |
    `boolean` | `float_xor` |
    `static NumberMathModificationInfo` | `instance` |
    `boolean` | `int_and` |
    `boolean` | `int_div` |
    `boolean` | `int_intdiv` |
    `boolean` | `int_leftShift` |
    `boolean` | `int_minus` |
    `boolean` | `int_mod` |
    `boolean` | `int_multiply` |
    `boolean` | `int_or` |
    `boolean` | `int_plus` |
    `boolean` | `int_rightShift` |
    `boolean` | `int_rightShiftUnsigned` |
    `boolean` | `int_xor` |
    `boolean` | `long_and` |
    `boolean` | `long_div` |
    `boolean` | `long_intdiv` |
    `boolean` | `long_leftShift` |
    `boolean` | `long_minus` |
    `boolean` | `long_mod` |
    `boolean` | `long_multiply` |
    `boolean` | `long_or` |
    `boolean` | `long_plus` |
    `boolean` | `long_rightShift` |
    `boolean` | `long_rightShiftUnsigned` |
    `boolean` | `long_xor` |
    `boolean` | `short_and` |
    `boolean` | `short_div` |
    `boolean` | `short_intdiv` |
    `boolean` | `short_leftShift` |
    `boolean` | `short_minus` |
    `boolean` | `short_mod` |
    `boolean` | `short_multiply` |
    `boolean` | `short_or` |
    `boolean` | `short_plus` |
    `boolean` | `short_rightShift` |
    `boolean` | `short_rightShiftUnsigned` |
    `boolean` | `short_xor` |

  - ### Methods Summary

    Methods
    Type Params | Return Type | Name and description
    --- | --- | ---
    `` | `static int` | `and(byte op1, byte op2)`
    `` | `static int` | `and(byte op1, short op2)`
    `` | `static int` | `and(byte op1, int op2)`
    `` | `static long` | `and(byte op1, long op2)`
    `` | `static int` | `and(short op1, byte op2)`
    `` | `static int` | `and(short op1, short op2)`
    `` | `static int` | `and(short op1, int op2)`
    `` | `static long` | `and(short op1, long op2)`
    `` | `static int` | `and(int op1, byte op2)`
    `` | `static int` | `and(int op1, short op2)`
    `` | `static int` | `and(int op1, int op2)`
    `` | `static long` | `and(int op1, long op2)`
    `` | `static long` | `and(long op1, byte op2)`
    `` | `static long` | `and(long op1, short op2)`
    `` | `static long` | `and(long op1, int op2)`
    `` | `static long` | `and(long op1, long op2)`
    `` | `void` | `checkIfStdMethod(MetaMethod method)`
    `` | `static int` | `div(byte op1, byte op2)`
    `` | `static int` | `div(byte op1, short op2)`
    `` | `static int` | `div(byte op1, int op2)`
    `` | `static long` | `div(byte op1, long op2)`
    `` | `static double` | `div(byte op1, float op2)`
    `` | `static double` | `div(byte op1, double op2)`
    `` | `static int` | `div(short op1, byte op2)`
    `` | `static int` | `div(short op1, short op2)`
    `` | `static int` | `div(short op1, int op2)`
    `` | `static long` | `div(short op1, long op2)`
    `` | `static double` | `div(short op1, float op2)`
    `` | `static double` | `div(short op1, double op2)`
    `` | `static int` | `div(int op1, byte op2)`
    `` | `static int` | `div(int op1, short op2)`
    `` | `static int` | `div(int op1, int op2)`
    `` | `static long` | `div(int op1, long op2)`
    `` | `static double` | `div(int op1, float op2)`
    `` | `static double` | `div(int op1, double op2)`
    `` | `static long` | `div(long op1, byte op2)`
    `` | `static long` | `div(long op1, short op2)`
    `` | `static long` | `div(long op1, int op2)`
    `` | `static long` | `div(long op1, long op2)`
    `` | `static double` | `div(long op1, float op2)`
    `` | `static double` | `div(long op1, double op2)`
    `` | `static double` | `div(float op1, byte op2)`
    `` | `static double` | `div(float op1, short op2)`
    `` | `static double` | `div(float op1, int op2)`
    `` | `static double` | `div(float op1, long op2)`
    `` | `static double` | `div(float op1, float op2)`
    `` | `static double` | `div(float op1, double op2)`
    `` | `static double` | `div(double op1, byte op2)`
    `` | `static double` | `div(double op1, short op2)`
    `` | `static double` | `div(double op1, int op2)`
    `` | `static double` | `div(double op1, long op2)`
    `` | `static double` | `div(double op1, float op2)`
    `` | `static double` | `div(double op1, double op2)`
    `` | `static int` | `intdiv(byte op1, byte op2)`
    `` | `static int` | `intdiv(byte op1, short op2)`
    `` | `static int` | `intdiv(byte op1, int op2)`
    `` | `static long` | `intdiv(byte op1, long op2)`
    `` | `static int` | `intdiv(short op1, byte op2)`
    `` | `static int` | `intdiv(short op1, short op2)`
    `` | `static int` | `intdiv(short op1, int op2)`
    `` | `static long` | `intdiv(short op1, long op2)`
    `` | `static int` | `intdiv(int op1, byte op2)`
    `` | `static int` | `intdiv(int op1, short op2)`
    `` | `static int` | `intdiv(int op1, int op2)`
    `` | `static long` | `intdiv(int op1, long op2)`
    `` | `static long` | `intdiv(long op1, byte op2)`
    `` | `static long` | `intdiv(long op1, short op2)`
    `` | `static long` | `intdiv(long op1, int op2)`
    `` | `static long` | `intdiv(long op1, long op2)`
    `` | `static int` | `leftShift(byte op1, byte op2)`
    `` | `static int` | `leftShift(byte op1, short op2)`
    `` | `static int` | `leftShift(byte op1, int op2)`
    `` | `static long` | `leftShift(byte op1, long op2)`
    `` | `static int` | `leftShift(short op1, byte op2)`
    `` | `static int` | `leftShift(short op1, short op2)`
    `` | `static int` | `leftShift(short op1, int op2)`
    `` | `static long` | `leftShift(short op1, long op2)`
    `` | `static int` | `leftShift(int op1, byte op2)`
    `` | `static int` | `leftShift(int op1, short op2)`
    `` | `static int` | `leftShift(int op1, int op2)`
    `` | `static long` | `leftShift(int op1, long op2)`
    `` | `static long` | `leftShift(long op1, byte op2)`
    `` | `static long` | `leftShift(long op1, short op2)`
    `` | `static long` | `leftShift(long op1, int op2)`
    `` | `static long` | `leftShift(long op1, long op2)`
    `` | `static int` | `minus(byte op1, byte op2)`
    `` | `static int` | `minus(byte op1, short op2)`
    `` | `static int` | `minus(byte op1, int op2)`
    `` | `static long` | `minus(byte op1, long op2)`
    `` | `static double` | `minus(byte op1, float op2)`
    `` | `static double` | `minus(byte op1, double op2)`
    `` | `static int` | `minus(short op1, byte op2)`
    `` | `static int` | `minus(short op1, short op2)`
    `` | `static int` | `minus(short op1, int op2)`
    `` | `static long` | `minus(short op1, long op2)`
    `` | `static double` | `minus(short op1, float op2)`
    `` | `static double` | `minus(short op1, double op2)`
    `` | `static int` | `minus(int op1, byte op2)`
    `` | `static int` | `minus(int op1, short op2)`
    `` | `static int` | `minus(int op1, int op2)`
    `` | `static long` | `minus(int op1, long op2)`
    `` | `static double` | `minus(int op1, float op2)`
    `` | `static double` | `minus(int op1, double op2)`
    `` | `static long` | `minus(long op1, byte op2)`
    `` | `static long` | `minus(long op1, short op2)`
    `` | `static long` | `minus(long op1, int op2)`
    `` | `static long` | `minus(long op1, long op2)`
    `` | `static double` | `minus(long op1, float op2)`
    `` | `static double` | `minus(long op1, double op2)`
    `` | `static double` | `minus(float op1, byte op2)`
    `` | `static double` | `minus(float op1, short op2)`
    `` | `static double` | `minus(float op1, int op2)`
    `` | `static double` | `minus(float op1, long op2)`
    `` | `static double` | `minus(float op1, float op2)`
    `` | `static double` | `minus(float op1, double op2)`
    `` | `static double` | `minus(double op1, byte op2)`
    `` | `static double` | `minus(double op1, short op2)`
    `` | `static double` | `minus(double op1, int op2)`
    `` | `static double` | `minus(double op1, long op2)`
    `` | `static double` | `minus(double op1, float op2)`
    `` | `static double` | `minus(double op1, double op2)`
    `` | `static int` | `mod(byte op1, byte op2)`
    `` | `static int` | `mod(byte op1, short op2)`
    `` | `static int` | `mod(byte op1, int op2)`
    `` | `static long` | `mod(byte op1, long op2)`
    `` | `static int` | `mod(short op1, byte op2)`
    `` | `static int` | `mod(short op1, short op2)`
    `` | `static int` | `mod(short op1, int op2)`
    `` | `static long` | `mod(short op1, long op2)`
    `` | `static int` | `mod(int op1, byte op2)`
    `` | `static int` | `mod(int op1, short op2)`
    `` | `static int` | `mod(int op1, int op2)`
    `` | `static long` | `mod(int op1, long op2)`
    `` | `static long` | `mod(long op1, byte op2)`
    `` | `static long` | `mod(long op1, short op2)`
    `` | `static long` | `mod(long op1, int op2)`
    `` | `static long` | `mod(long op1, long op2)`
    `` | `static int` | `multiply(byte op1, byte op2)`
    `` | `static int` | `multiply(byte op1, short op2)`
    `` | `static int` | `multiply(byte op1, int op2)`
    `` | `static long` | `multiply(byte op1, long op2)`
    `` | `static double` | `multiply(byte op1, float op2)`
    `` | `static double` | `multiply(byte op1, double op2)`
    `` | `static int` | `multiply(short op1, byte op2)`
    `` | `static int` | `multiply(short op1, short op2)`
    `` | `static int` | `multiply(short op1, int op2)`
    `` | `static long` | `multiply(short op1, long op2)`
    `` | `static double` | `multiply(short op1, float op2)`
    `` | `static double` | `multiply(short op1, double op2)`
    `` | `static int` | `multiply(int op1, byte op2)`
    `` | `static int` | `multiply(int op1, short op2)`
    `` | `static int` | `multiply(int op1, int op2)`
    `` | `static long` | `multiply(int op1, long op2)`
    `` | `static double` | `multiply(int op1, float op2)`
    `` | `static double` | `multiply(int op1, double op2)`
    `` | `static long` | `multiply(long op1, byte op2)`
    `` | `static long` | `multiply(long op1, short op2)`
    `` | `static long` | `multiply(long op1, int op2)`
    `` | `static long` | `multiply(long op1, long op2)`
    `` | `static double` | `multiply(long op1, float op2)`
    `` | `static double` | `multiply(long op1, double op2)`
    `` | `static double` | `multiply(float op1, byte op2)`
    `` | `static double` | `multiply(float op1, short op2)`
    `` | `static double` | `multiply(float op1, int op2)`
    `` | `static double` | `multiply(float op1, long op2)`
    `` | `static double` | `multiply(float op1, float op2)`
    `` | `static double` | `multiply(float op1, double op2)`
    `` | `static double` | `multiply(double op1, byte op2)`
    `` | `static double` | `multiply(double op1, short op2)`
    `` | `static double` | `multiply(double op1, int op2)`
    `` | `static double` | `multiply(double op1, long op2)`
    `` | `static double` | `multiply(double op1, float op2)`
    `` | `static double` | `multiply(double op1, double op2)`
    `` | `static int` | `or(byte op1, byte op2)`
    `` | `static int` | `or(byte op1, short op2)`
    `` | `static int` | `or(byte op1, int op2)`
    `` | `static long` | `or(byte op1, long op2)`
    `` | `static int` | `or(short op1, byte op2)`
    `` | `static int` | `or(short op1, short op2)`
    `` | `static int` | `or(short op1, int op2)`
    `` | `static long` | `or(short op1, long op2)`
    `` | `static int` | `or(int op1, byte op2)`
    `` | `static int` | `or(int op1, short op2)`
    `` | `static int` | `or(int op1, int op2)`
    `` | `static long` | `or(int op1, long op2)`
    `` | `static long` | `or(long op1, byte op2)`
    `` | `static long` | `or(long op1, short op2)`
    `` | `static long` | `or(long op1, int op2)`
    `` | `static long` | `or(long op1, long op2)`
    `` | `static int` | `plus(byte op1, byte op2)`
    `` | `static int` | `plus(byte op1, short op2)`
    `` | `static int` | `plus(byte op1, int op2)`
    `` | `static long` | `plus(byte op1, long op2)`
    `` | `static double` | `plus(byte op1, float op2)`
    `` | `static double` | `plus(byte op1, double op2)`
    `` | `static int` | `plus(short op1, byte op2)`
    `` | `static int` | `plus(short op1, short op2)`
    `` | `static int` | `plus(short op1, int op2)`
    `` | `static long` | `plus(short op1, long op2)`
    `` | `static double` | `plus(short op1, float op2)`
    `` | `static double` | `plus(short op1, double op2)`
    `` | `static int` | `plus(int op1, byte op2)`
    `` | `static int` | `plus(int op1, short op2)`
    `` | `static int` | `plus(int op1, int op2)`
    `` | `static long` | `plus(int op1, long op2)`
    `` | `static double` | `plus(int op1, float op2)`
    `` | `static double` | `plus(int op1, double op2)`
    `` | `static long` | `plus(long op1, byte op2)`
    `` | `static long` | `plus(long op1, short op2)`
    `` | `static long` | `plus(long op1, int op2)`
    `` | `static long` | `plus(long op1, long op2)`
    `` | `static double` | `plus(long op1, float op2)`
    `` | `static double` | `plus(long op1, double op2)`
    `` | `static double` | `plus(float op1, byte op2)`
    `` | `static double` | `plus(float op1, short op2)`
    `` | `static double` | `plus(float op1, int op2)`
    `` | `static double` | `plus(float op1, long op2)`
    `` | `static double` | `plus(float op1, float op2)`
    `` | `static double` | `plus(float op1, double op2)`
    `` | `static double` | `plus(double op1, byte op2)`
    `` | `static double` | `plus(double op1, short op2)`
    `` | `static double` | `plus(double op1, int op2)`
    `` | `static double` | `plus(double op1, long op2)`
    `` | `static double` | `plus(double op1, float op2)`
    `` | `static double` | `plus(double op1, double op2)`
    `` | `static int` | `rightShift(byte op1, byte op2)`
    `` | `static int` | `rightShift(byte op1, short op2)`
    `` | `static int` | `rightShift(byte op1, int op2)`
    `` | `static long` | `rightShift(byte op1, long op2)`
    `` | `static int` | `rightShift(short op1, byte op2)`
    `` | `static int` | `rightShift(short op1, short op2)`
    `` | `static int` | `rightShift(short op1, int op2)`
    `` | `static long` | `rightShift(short op1, long op2)`
    `` | `static int` | `rightShift(int op1, byte op2)`
    `` | `static int` | `rightShift(int op1, short op2)`
    `` | `static int` | `rightShift(int op1, int op2)`
    `` | `static long` | `rightShift(int op1, long op2)`
    `` | `static long` | `rightShift(long op1, byte op2)`
    `` | `static long` | `rightShift(long op1, short op2)`
    `` | `static long` | `rightShift(long op1, int op2)`
    `` | `static long` | `rightShift(long op1, long op2)`
    `` | `static int` | `rightShiftUnsigned(byte op1, byte op2)`
    `` | `static int` | `rightShiftUnsigned(byte op1, short op2)`
    `` | `static int` | `rightShiftUnsigned(byte op1, int op2)`
    `` | `static long` | `rightShiftUnsigned(byte op1, long op2)`
    `` | `static int` | `rightShiftUnsigned(short op1, byte op2)`
    `` | `static int` | `rightShiftUnsigned(short op1, short op2)`
    `` | `static int` | `rightShiftUnsigned(short op1, int op2)`
    `` | `static long` | `rightShiftUnsigned(short op1, long op2)`
    `` | `static int` | `rightShiftUnsigned(int op1, byte op2)`
    `` | `static int` | `rightShiftUnsigned(int op1, short op2)`
    `` | `static int` | `rightShiftUnsigned(int op1, int op2)`
    `` | `static long` | `rightShiftUnsigned(int op1, long op2)`
    `` | `static long` | `rightShiftUnsigned(long op1, byte op2)`
    `` | `static long` | `rightShiftUnsigned(long op1, short op2)`
    `` | `static long` | `rightShiftUnsigned(long op1, int op2)`
    `` | `static long` | `rightShiftUnsigned(long op1, long op2)`
    `` | `static int` | `xor(byte op1, byte op2)`
    `` | `static int` | `xor(byte op1, short op2)`
    `` | `static int` | `xor(byte op1, int op2)`
    `` | `static long` | `xor(byte op1, long op2)`
    `` | `static int` | `xor(short op1, byte op2)`
    `` | `static int` | `xor(short op1, short op2)`
    `` | `static int` | `xor(short op1, int op2)`
    `` | `static long` | `xor(short op1, long op2)`
    `` | `static int` | `xor(int op1, byte op2)`
    `` | `static int` | `xor(int op1, short op2)`
    `` | `static int` | `xor(int op1, int op2)`
    `` | `static long` | `xor(int op1, long op2)`
    `` | `static long` | `xor(long op1, byte op2)`
    `` | `static long` | `xor(long op1, short op2)`
    `` | `static long` | `xor(long op1, int op2)`
    `` | `static long` | `xor(long op1, long op2)`

  - ### Inherited Methods Summary

    Inherited Methods
    Methods inherited from class | Name
    --- | ---
    `class Object` | `equals, toString, hashCode, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### public boolean byte_and

    - #### public boolean byte_div

    - #### public boolean byte_intdiv

    - #### public boolean byte_leftShift

    - #### public boolean byte_minus

    - #### public boolean byte_mod

    - #### public boolean byte_multiply

    - #### public boolean byte_or

    - #### public boolean byte_plus

    - #### public boolean byte_rightShift

    - #### public boolean byte_rightShiftUnsigned

    - #### public boolean byte_xor

    - #### public boolean double_and

    - #### public boolean double_div

    - #### public boolean double_intdiv

    - #### public boolean double_leftShift

    - #### public boolean double_minus

    - #### public boolean double_mod

    - #### public boolean double_multiply

    - #### public boolean double_or

    - #### public boolean double_plus

    - #### public boolean double_rightShift

    - #### public boolean double_rightShiftUnsigned

    - #### public boolean double_xor

    - #### public boolean float_and

    - #### public boolean float_div

    - #### public boolean float_intdiv

    - #### public boolean float_leftShift

    - #### public boolean float_minus

    - #### public boolean float_mod

    - #### public boolean float_multiply

    - #### public boolean float_or

    - #### public boolean float_plus

    - #### public boolean float_rightShift

    - #### public boolean float_rightShiftUnsigned

    - #### public boolean float_xor

    - #### public static final NumberMathModificationInfo instance

    - #### public boolean int_and

    - #### public boolean int_div

    - #### public boolean int_intdiv

    - #### public boolean int_leftShift

    - #### public boolean int_minus

    - #### public boolean int_mod

    - #### public boolean int_multiply

    - #### public boolean int_or

    - #### public boolean int_plus

    - #### public boolean int_rightShift

    - #### public boolean int_rightShiftUnsigned

    - #### public boolean int_xor

    - #### public boolean long_and

    - #### public boolean long_div

    - #### public boolean long_intdiv

    - #### public boolean long_leftShift

    - #### public boolean long_minus

    - #### public boolean long_mod

    - #### public boolean long_multiply

    - #### public boolean long_or

    - #### public boolean long_plus

    - #### public boolean long_rightShift

    - #### public boolean long_rightShiftUnsigned

    - #### public boolean long_xor

    - #### public boolean short_and

    - #### public boolean short_div

    - #### public boolean short_intdiv

    - #### public boolean short_leftShift

    - #### public boolean short_minus

    - #### public boolean short_mod

    - #### public boolean short_multiply

    - #### public boolean short_or

    - #### public boolean short_plus

    - #### public boolean short_rightShift

    - #### public boolean short_rightShiftUnsigned

    - #### public boolean short_xor

  - ### Method Detail

    - #### public static int and(byte op1, byte op2)

    - #### public static int and(byte op1, short op2)

    - #### public static int and(byte op1, int op2)

    - #### public static long and(byte op1, long op2)

    - #### public static int and(short op1, byte op2)

    - #### public static int and(short op1, short op2)

    - #### public static int and(short op1, int op2)

    - #### public static long and(short op1, long op2)

    - #### public static int and(int op1, byte op2)

    - #### public static int and(int op1, short op2)

    - #### public static int and(int op1, int op2)

    - #### public static long and(int op1, long op2)

    - #### public static long and(long op1, byte op2)

    - #### public static long and(long op1, short op2)

    - #### public static long and(long op1, int op2)

    - #### public static long and(long op1, long op2)

    - #### public void checkIfStdMethod(MetaMethod method)

    - #### public static int div(byte op1, byte op2)

    - #### public static int div(byte op1, short op2)

    - #### public static int div(byte op1, int op2)

    - #### public static long div(byte op1, long op2)

    - #### public static double div(byte op1, float op2)

    - #### public static double div(byte op1, double op2)

    - #### public static int div(short op1, byte op2)

    - #### public static int div(short op1, short op2)

    - #### public static int div(short op1, int op2)

    - #### public static long div(short op1, long op2)

    - #### public static double div(short op1, float op2)

    - #### public static double div(short op1, double op2)

    - #### public static int div(int op1, byte op2)

    - #### public static int div(int op1, short op2)

    - #### public static int div(int op1, int op2)

    - #### public static long div(int op1, long op2)

    - #### public static double div(int op1, float op2)

    - #### public static double div(int op1, double op2)

    - #### public static long div(long op1, byte op2)

    - #### public static long div(long op1, short op2)

    - #### public static long div(long op1, int op2)

    - #### public static long div(long op1, long op2)

    - #### public static double div(long op1, float op2)

    - #### public static double div(long op1, double op2)

    - #### public static double div(float op1, byte op2)

    - #### public static double div(float op1, short op2)

    - #### public static double div(float op1, int op2)

    - #### public static double div(float op1, long op2)

    - #### public static double div(float op1, float op2)

    - #### public static double div(float op1, double op2)

    - #### public static double div(double op1, byte op2)

    - #### public static double div(double op1, short op2)

    - #### public static double div(double op1, int op2)

    - #### public static double div(double op1, long op2)

    - #### public static double div(double op1, float op2)

    - #### public static double div(double op1, double op2)

    - #### public static int intdiv(byte op1, byte op2)

    - #### public static int intdiv(byte op1, short op2)

    - #### public static int intdiv(byte op1, int op2)

    - #### public static long intdiv(byte op1, long op2)

    - #### public static int intdiv(short op1, byte op2)

    - #### public static int intdiv(short op1, short op2)

    - #### public static int intdiv(short op1, int op2)

    - #### public static long intdiv(short op1, long op2)

    - #### public static int intdiv(int op1, byte op2)

    - #### public static int intdiv(int op1, short op2)

    - #### public static int intdiv(int op1, int op2)

    - #### public static long intdiv(int op1, long op2)

    - #### public static long intdiv(long op1, byte op2)

    - #### public static long intdiv(long op1, short op2)

    - #### public static long intdiv(long op1, int op2)

    - #### public static long intdiv(long op1, long op2)

    - #### public static int leftShift(byte op1, byte op2)

    - #### public static int leftShift(byte op1, short op2)

    - #### public static int leftShift(byte op1, int op2)

    - #### public static long leftShift(byte op1, long op2)

    - #### public static int leftShift(short op1, byte op2)

    - #### public static int leftShift(short op1, short op2)

    - #### public static int leftShift(short op1, int op2)

    - #### public static long leftShift(short op1, long op2)

    - #### public static int leftShift(int op1, byte op2)

    - #### public static int leftShift(int op1, short op2)

    - #### public static int leftShift(int op1, int op2)

    - #### public static long leftShift(int op1, long op2)

    - #### public static long leftShift(long op1, byte op2)

    - #### public static long leftShift(long op1, short op2)

    - #### public static long leftShift(long op1, int op2)

    - #### public static long leftShift(long op1, long op2)

    - #### public static int minus(byte op1, byte op2)

    - #### public static int minus(byte op1, short op2)

    - #### public static int minus(byte op1, int op2)

    - #### public static long minus(byte op1, long op2)

    - #### public static double minus(byte op1, float op2)

    - #### public static double minus(byte op1, double op2)

    - #### public static int minus(short op1, byte op2)

    - #### public static int minus(short op1, short op2)

    - #### public static int minus(short op1, int op2)

    - #### public static long minus(short op1, long op2)

    - #### public static double minus(short op1, float op2)

    - #### public static double minus(short op1, double op2)

    - #### public static int minus(int op1, byte op2)

    - #### public static int minus(int op1, short op2)

    - #### public static int minus(int op1, int op2)

    - #### public static long minus(int op1, long op2)

    - #### public static double minus(int op1, float op2)

    - #### public static double minus(int op1, double op2)

    - #### public static long minus(long op1, byte op2)

    - #### public static long minus(long op1, short op2)

    - #### public static long minus(long op1, int op2)

    - #### public static long minus(long op1, long op2)

    - #### public static double minus(long op1, float op2)

    - #### public static double minus(long op1, double op2)

    - #### public static double minus(float op1, byte op2)

    - #### public static double minus(float op1, short op2)

    - #### public static double minus(float op1, int op2)

    - #### public static double minus(float op1, long op2)

    - #### public static double minus(float op1, float op2)

    - #### public static double minus(float op1, double op2)

    - #### public static double minus(double op1, byte op2)

    - #### public static double minus(double op1, short op2)

    - #### public static double minus(double op1, int op2)

    - #### public static double minus(double op1, long op2)

    - #### public static double minus(double op1, float op2)

    - #### public static double minus(double op1, double op2)

    - #### public static int mod(byte op1, byte op2)

    - #### public static int mod(byte op1, short op2)

    - #### public static int mod(byte op1, int op2)

    - #### public static long mod(byte op1, long op2)

    - #### public static int mod(short op1, byte op2)

    - #### public static int mod(short op1, short op2)

    - #### public static int mod(short op1, int op2)

    - #### public static long mod(short op1, long op2)

    - #### public static int mod(int op1, byte op2)

    - #### public static int mod(int op1, short op2)

    - #### public static int mod(int op1, int op2)

    - #### public static long mod(int op1, long op2)

    - #### public static long mod(long op1, byte op2)

    - #### public static long mod(long op1, short op2)

    - #### public static long mod(long op1, int op2)

    - #### public static long mod(long op1, long op2)

    - #### public static int multiply(byte op1, byte op2)

    - #### public static int multiply(byte op1, short op2)

    - #### public static int multiply(byte op1, int op2)

    - #### public static long multiply(byte op1, long op2)

    - #### public static double multiply(byte op1, float op2)

    - #### public static double multiply(byte op1, double op2)

    - #### public static int multiply(short op1, byte op2)

    - #### public static int multiply(short op1, short op2)

    - #### public static int multiply(short op1, int op2)

    - #### public static long multiply(short op1, long op2)

    - #### public static double multiply(short op1, float op2)

    - #### public static double multiply(short op1, double op2)

    - #### public static int multiply(int op1, byte op2)

    - #### public static int multiply(int op1, short op2)

    - #### public static int multiply(int op1, int op2)

    - #### public static long multiply(int op1, long op2)

    - #### public static double multiply(int op1, float op2)

    - #### public static double multiply(int op1, double op2)

    - #### public static long multiply(long op1, byte op2)

    - #### public static long multiply(long op1, short op2)

    - #### public static long multiply(long op1, int op2)

    - #### public static long multiply(long op1, long op2)

    - #### public static double multiply(long op1, float op2)

    - #### public static double multiply(long op1, double op2)

    - #### public static double multiply(float op1, byte op2)

    - #### public static double multiply(float op1, short op2)

    - #### public static double multiply(float op1, int op2)

    - #### public static double multiply(float op1, long op2)

    - #### public static double multiply(float op1, float op2)

    - #### public static double multiply(float op1, double op2)

    - #### public static double multiply(double op1, byte op2)

    - #### public static double multiply(double op1, short op2)

    - #### public static double multiply(double op1, int op2)

    - #### public static double multiply(double op1, long op2)

    - #### public static double multiply(double op1, float op2)

    - #### public static double multiply(double op1, double op2)

    - #### public static int or(byte op1, byte op2)

    - #### public static int or(byte op1, short op2)

    - #### public static int or(byte op1, int op2)

    - #### public static long or(byte op1, long op2)

    - #### public static int or(short op1, byte op2)

    - #### public static int or(short op1, short op2)

    - #### public static int or(short op1, int op2)

    - #### public static long or(short op1, long op2)

    - #### public static int or(int op1, byte op2)

    - #### public static int or(int op1, short op2)

    - #### public static int or(int op1, int op2)

    - #### public static long or(int op1, long op2)

    - #### public static long or(long op1, byte op2)

    - #### public static long or(long op1, short op2)

    - #### public static long or(long op1, int op2)

    - #### public static long or(long op1, long op2)

    - #### public static int plus(byte op1, byte op2)

    - #### public static int plus(byte op1, short op2)

    - #### public static int plus(byte op1, int op2)

    - #### public static long plus(byte op1, long op2)

    - #### public static double plus(byte op1, float op2)

    - #### public static double plus(byte op1, double op2)

    - #### public static int plus(short op1, byte op2)

    - #### public static int plus(short op1, short op2)

    - #### public static int plus(short op1, int op2)

    - #### public static long plus(short op1, long op2)

    - #### public static double plus(short op1, float op2)

    - #### public static double plus(short op1, double op2)

    - #### public static int plus(int op1, byte op2)

    - #### public static int plus(int op1, short op2)

    - #### public static int plus(int op1, int op2)

    - #### public static long plus(int op1, long op2)

    - #### public static double plus(int op1, float op2)

    - #### public static double plus(int op1, double op2)

    - #### public static long plus(long op1, byte op2)

    - #### public static long plus(long op1, short op2)

    - #### public static long plus(long op1, int op2)

    - #### public static long plus(long op1, long op2)

    - #### public static double plus(long op1, float op2)

    - #### public static double plus(long op1, double op2)

    - #### public static double plus(float op1, byte op2)

    - #### public static double plus(float op1, short op2)

    - #### public static double plus(float op1, int op2)

    - #### public static double plus(float op1, long op2)

    - #### public static double plus(float op1, float op2)

    - #### public static double plus(float op1, double op2)

    - #### public static double plus(double op1, byte op2)

    - #### public static double plus(double op1, short op2)

    - #### public static double plus(double op1, int op2)

    - #### public static double plus(double op1, long op2)

    - #### public static double plus(double op1, float op2)

    - #### public static double plus(double op1, double op2)

    - #### public static int rightShift(byte op1, byte op2)

    - #### public static int rightShift(byte op1, short op2)

    - #### public static int rightShift(byte op1, int op2)

    - #### public static long rightShift(byte op1, long op2)

    - #### public static int rightShift(short op1, byte op2)

    - #### public static int rightShift(short op1, short op2)

    - #### public static int rightShift(short op1, int op2)

    - #### public static long rightShift(short op1, long op2)

    - #### public static int rightShift(int op1, byte op2)

    - #### public static int rightShift(int op1, short op2)

    - #### public static int rightShift(int op1, int op2)

    - #### public static long rightShift(int op1, long op2)

    - #### public static long rightShift(long op1, byte op2)

    - #### public static long rightShift(long op1, short op2)

    - #### public static long rightShift(long op1, int op2)

    - #### public static long rightShift(long op1, long op2)

    - #### public static int rightShiftUnsigned(byte op1, byte op2)

    - #### public static int rightShiftUnsigned(byte op1, short op2)

    - #### public static int rightShiftUnsigned(byte op1, int op2)

    - #### public static long rightShiftUnsigned(byte op1, long op2)

    - #### public static int rightShiftUnsigned(short op1, byte op2)

    - #### public static int rightShiftUnsigned(short op1, short op2)

    - #### public static int rightShiftUnsigned(short op1, int op2)

    - #### public static long rightShiftUnsigned(short op1, long op2)

    - #### public static int rightShiftUnsigned(int op1, byte op2)

    - #### public static int rightShiftUnsigned(int op1, short op2)

    - #### public static int rightShiftUnsigned(int op1, int op2)

    - #### public static long rightShiftUnsigned(int op1, long op2)

    - #### public static long rightShiftUnsigned(long op1, byte op2)

    - #### public static long rightShiftUnsigned(long op1, short op2)

    - #### public static long rightShiftUnsigned(long op1, int op2)

    - #### public static long rightShiftUnsigned(long op1, long op2)

    - #### public static int xor(byte op1, byte op2)

    - #### public static int xor(byte op1, short op2)

    - #### public static int xor(byte op1, int op2)

    - #### public static long xor(byte op1, long op2)

    - #### public static int xor(short op1, byte op2)

    - #### public static int xor(short op1, short op2)

    - #### public static int xor(short op1, int op2)

    - #### public static long xor(short op1, long op2)

    - #### public static int xor(int op1, byte op2)

    - #### public static int xor(int op1, short op2)

    - #### public static int xor(int op1, int op2)

    - #### public static long xor(int op1, long op2)

    - #### public static long xor(long op1, byte op2)

    - #### public static long xor(long op1, short op2)

    - #### public static long xor(long op1, int op2)

    - #### public static long xor(long op1, long op2)