Package org.codehaus.groovy.runtime.typehandling

# Class NumberMathModificationInfo

java.lang.Object
org.codehaus.groovy.runtime.typehandling.NumberMathModificationInfo

public class NumberMathModificationInfo extends Object

- ## Field Summary

  Fields
  Modifier and Type
  Field
  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 final 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`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static int`
  `and(byte op1, byte op2)`
  `static int`
  `and(byte op1, int op2)`
  `static long`
  `and(byte op1, long op2)`
  `static int`
  `and(byte op1, short op2)`
  `static int`
  `and(int op1, byte op2)`
  `static int`
  `and(int op1, int op2)`
  `static long`
  `and(int op1, long op2)`
  `static int`
  `and(int op1, short op2)`
  `static long`
  `and(long op1, byte op2)`
  `static long`
  `and(long op1, int op2)`
  `static long`
  `and(long op1, long op2)`
  `static long`
  `and(long op1, short op2)`
  `static int`
  `and(short op1, byte op2)`
  `static int`
  `and(short op1, int op2)`
  `static long`
  `and(short op1, long op2)`
  `static int`
  `and(short op1, short op2)`
  `void`
  `checkIfStdMethod(MetaMethod method)`
  `static int`
  `div(byte op1, byte op2)`
  `static double`
  `div(byte op1, double op2)`
  `static double`
  `div(byte op1, float op2)`
  `static int`
  `div(byte op1, int op2)`
  `static long`
  `div(byte op1, long op2)`
  `static int`
  `div(byte op1, short op2)`
  `static double`
  `div(double op1, byte op2)`
  `static double`
  `div(double op1, double op2)`
  `static double`
  `div(double op1, float op2)`
  `static double`
  `div(double op1, int op2)`
  `static double`
  `div(double op1, long op2)`
  `static double`
  `div(double op1, short op2)`
  `static double`
  `div(float op1, byte op2)`
  `static double`
  `div(float op1, double op2)`
  `static double`
  `div(float op1, float op2)`
  `static double`
  `div(float op1, int op2)`
  `static double`
  `div(float op1, long op2)`
  `static double`
  `div(float op1, short op2)`
  `static int`
  `div(int op1, byte op2)`
  `static double`
  `div(int op1, double op2)`
  `static double`
  `div(int op1, float op2)`
  `static int`
  `div(int op1, int op2)`
  `static long`
  `div(int op1, long op2)`
  `static int`
  `div(int op1, short op2)`
  `static long`
  `div(long op1, byte op2)`
  `static double`
  `div(long op1, double op2)`
  `static double`
  `div(long op1, float op2)`
  `static long`
  `div(long op1, int op2)`
  `static long`
  `div(long op1, long op2)`
  `static long`
  `div(long op1, short op2)`
  `static int`
  `div(short op1, byte op2)`
  `static double`
  `div(short op1, double op2)`
  `static double`
  `div(short op1, float op2)`
  `static int`
  `div(short op1, int op2)`
  `static long`
  `div(short op1, long op2)`
  `static int`
  `div(short op1, short op2)`
  `static int`
  `intdiv(byte op1, byte op2)`
  `static int`
  `intdiv(byte op1, int op2)`
  `static long`
  `intdiv(byte op1, long op2)`
  `static int`
  `intdiv(byte op1, short op2)`
  `static int`
  `intdiv(int op1, byte op2)`
  `static int`
  `intdiv(int op1, int op2)`
  `static long`
  `intdiv(int op1, long op2)`
  `static int`
  `intdiv(int op1, short op2)`
  `static long`
  `intdiv(long op1, byte op2)`
  `static long`
  `intdiv(long op1, int op2)`
  `static long`
  `intdiv(long op1, long op2)`
  `static long`
  `intdiv(long op1, short op2)`
  `static int`
  `intdiv(short op1, byte op2)`
  `static int`
  `intdiv(short op1, int op2)`
  `static long`
  `intdiv(short op1, long op2)`
  `static int`
  `intdiv(short op1, short op2)`
  `static int`
  `leftShift(byte op1, byte op2)`
  `static int`
  `leftShift(byte op1, int op2)`
  `static long`
  `leftShift(byte op1, long op2)`
  `static int`
  `leftShift(byte op1, short op2)`
  `static int`
  `leftShift(int op1, byte op2)`
  `static int`
  `leftShift(int op1, int op2)`
  `static long`
  `leftShift(int op1, long op2)`
  `static int`
  `leftShift(int op1, short op2)`
  `static long`
  `leftShift(long op1, byte op2)`
  `static long`
  `leftShift(long op1, int op2)`
  `static long`
  `leftShift(long op1, long op2)`
  `static long`
  `leftShift(long op1, short op2)`
  `static int`
  `leftShift(short op1, byte op2)`
  `static int`
  `leftShift(short op1, int op2)`
  `static long`
  `leftShift(short op1, long op2)`
  `static int`
  `leftShift(short op1, short op2)`
  `static int`
  `minus(byte op1, byte op2)`
  `static double`
  `minus(byte op1, double op2)`
  `static double`
  `minus(byte op1, float op2)`
  `static int`
  `minus(byte op1, int op2)`
  `static long`
  `minus(byte op1, long op2)`
  `static int`
  `minus(byte op1, short op2)`
  `static double`
  `minus(double op1, byte op2)`
  `static double`
  `minus(double op1, double op2)`
  `static double`
  `minus(double op1, float op2)`
  `static double`
  `minus(double op1, int op2)`
  `static double`
  `minus(double op1, long op2)`
  `static double`
  `minus(double op1, short op2)`
  `static double`
  `minus(float op1, byte op2)`
  `static double`
  `minus(float op1, double op2)`
  `static double`
  `minus(float op1, float op2)`
  `static double`
  `minus(float op1, int op2)`
  `static double`
  `minus(float op1, long op2)`
  `static double`
  `minus(float op1, short op2)`
  `static int`
  `minus(int op1, byte op2)`
  `static double`
  `minus(int op1, double op2)`
  `static double`
  `minus(int op1, float op2)`
  `static int`
  `minus(int op1, int op2)`
  `static long`
  `minus(int op1, long op2)`
  `static int`
  `minus(int op1, short op2)`
  `static long`
  `minus(long op1, byte op2)`
  `static double`
  `minus(long op1, double op2)`
  `static double`
  `minus(long op1, float op2)`
  `static long`
  `minus(long op1, int op2)`
  `static long`
  `minus(long op1, long op2)`
  `static long`
  `minus(long op1, short op2)`
  `static int`
  `minus(short op1, byte op2)`
  `static double`
  `minus(short op1, double op2)`
  `static double`
  `minus(short op1, float op2)`
  `static int`
  `minus(short op1, int op2)`
  `static long`
  `minus(short op1, long op2)`
  `static int`
  `minus(short op1, short op2)`
  `static int`
  `mod(byte op1, byte op2)`
  `static int`
  `mod(byte op1, int op2)`
  `static long`
  `mod(byte op1, long op2)`
  `static int`
  `mod(byte op1, short op2)`
  `static int`
  `mod(int op1, byte op2)`
  `static int`
  `mod(int op1, int op2)`
  `static long`
  `mod(int op1, long op2)`
  `static int`
  `mod(int op1, short op2)`
  `static long`
  `mod(long op1, byte op2)`
  `static long`
  `mod(long op1, int op2)`
  `static long`
  `mod(long op1, long op2)`
  `static long`
  `mod(long op1, short op2)`
  `static int`
  `mod(short op1, byte op2)`
  `static int`
  `mod(short op1, int op2)`
  `static long`
  `mod(short op1, long op2)`
  `static int`
  `mod(short op1, short op2)`
  `static int`
  `multiply(byte op1, byte op2)`
  `static double`
  `multiply(byte op1, double op2)`
  `static double`
  `multiply(byte op1, float op2)`
  `static int`
  `multiply(byte op1, int op2)`
  `static long`
  `multiply(byte op1, long op2)`
  `static int`
  `multiply(byte op1, short op2)`
  `static double`
  `multiply(double op1, byte op2)`
  `static double`
  `multiply(double op1, double op2)`
  `static double`
  `multiply(double op1, float op2)`
  `static double`
  `multiply(double op1, int op2)`
  `static double`
  `multiply(double op1, long op2)`
  `static double`
  `multiply(double op1, short op2)`
  `static double`
  `multiply(float op1, byte op2)`
  `static double`
  `multiply(float op1, double op2)`
  `static double`
  `multiply(float op1, float op2)`
  `static double`
  `multiply(float op1, int op2)`
  `static double`
  `multiply(float op1, long op2)`
  `static double`
  `multiply(float op1, short op2)`
  `static int`
  `multiply(int op1, byte op2)`
  `static double`
  `multiply(int op1, double op2)`
  `static double`
  `multiply(int op1, float op2)`
  `static int`
  `multiply(int op1, int op2)`
  `static long`
  `multiply(int op1, long op2)`
  `static int`
  `multiply(int op1, short op2)`
  `static long`
  `multiply(long op1, byte op2)`
  `static double`
  `multiply(long op1, double op2)`
  `static double`
  `multiply(long op1, float op2)`
  `static long`
  `multiply(long op1, int op2)`
  `static long`
  `multiply(long op1, long op2)`
  `static long`
  `multiply(long op1, short op2)`
  `static int`
  `multiply(short op1, byte op2)`
  `static double`
  `multiply(short op1, double op2)`
  `static double`
  `multiply(short op1, float op2)`
  `static int`
  `multiply(short op1, int op2)`
  `static long`
  `multiply(short op1, long op2)`
  `static int`
  `multiply(short op1, short op2)`
  `static int`
  `or(byte op1, byte op2)`
  `static int`
  `or(byte op1, int op2)`
  `static long`
  `or(byte op1, long op2)`
  `static int`
  `or(byte op1, short op2)`
  `static int`
  `or(int op1, byte op2)`
  `static int`
  `or(int op1, int op2)`
  `static long`
  `or(int op1, long op2)`
  `static int`
  `or(int op1, short op2)`
  `static long`
  `or(long op1, byte op2)`
  `static long`
  `or(long op1, int op2)`
  `static long`
  `or(long op1, long op2)`
  `static long`
  `or(long op1, short op2)`
  `static int`
  `or(short op1, byte op2)`
  `static int`
  `or(short op1, int op2)`
  `static long`
  `or(short op1, long op2)`
  `static int`
  `or(short op1, short op2)`
  `static int`
  `plus(byte op1, byte op2)`
  `static double`
  `plus(byte op1, double op2)`
  `static double`
  `plus(byte op1, float op2)`
  `static int`
  `plus(byte op1, int op2)`
  `static long`
  `plus(byte op1, long op2)`
  `static int`
  `plus(byte op1, short op2)`
  `static double`
  `plus(double op1, byte op2)`
  `static double`
  `plus(double op1, double op2)`
  `static double`
  `plus(double op1, float op2)`
  `static double`
  `plus(double op1, int op2)`
  `static double`
  `plus(double op1, long op2)`
  `static double`
  `plus(double op1, short op2)`
  `static double`
  `plus(float op1, byte op2)`
  `static double`
  `plus(float op1, double op2)`
  `static double`
  `plus(float op1, float op2)`
  `static double`
  `plus(float op1, int op2)`
  `static double`
  `plus(float op1, long op2)`
  `static double`
  `plus(float op1, short op2)`
  `static int`
  `plus(int op1, byte op2)`
  `static double`
  `plus(int op1, double op2)`
  `static double`
  `plus(int op1, float op2)`
  `static int`
  `plus(int op1, int op2)`
  `static long`
  `plus(int op1, long op2)`
  `static int`
  `plus(int op1, short op2)`
  `static long`
  `plus(long op1, byte op2)`
  `static double`
  `plus(long op1, double op2)`
  `static double`
  `plus(long op1, float op2)`
  `static long`
  `plus(long op1, int op2)`
  `static long`
  `plus(long op1, long op2)`
  `static long`
  `plus(long op1, short op2)`
  `static int`
  `plus(short op1, byte op2)`
  `static double`
  `plus(short op1, double op2)`
  `static double`
  `plus(short op1, float op2)`
  `static int`
  `plus(short op1, int op2)`
  `static long`
  `plus(short op1, long op2)`
  `static int`
  `plus(short op1, short op2)`
  `static int`
  `rightShift(byte op1, byte op2)`
  `static int`
  `rightShift(byte op1, int op2)`
  `static long`
  `rightShift(byte op1, long op2)`
  `static int`
  `rightShift(byte op1, short op2)`
  `static int`
  `rightShift(int op1, byte op2)`
  `static int`
  `rightShift(int op1, int op2)`
  `static long`
  `rightShift(int op1, long op2)`
  `static int`
  `rightShift(int op1, short op2)`
  `static long`
  `rightShift(long op1, byte op2)`
  `static long`
  `rightShift(long op1, int op2)`
  `static long`
  `rightShift(long op1, long op2)`
  `static long`
  `rightShift(long op1, short op2)`
  `static int`
  `rightShift(short op1, byte op2)`
  `static int`
  `rightShift(short op1, int op2)`
  `static long`
  `rightShift(short op1, long op2)`
  `static int`
  `rightShift(short op1, short op2)`
  `static int`
  `rightShiftUnsigned(byte op1, byte op2)`
  `static int`
  `rightShiftUnsigned(byte op1, int op2)`
  `static long`
  `rightShiftUnsigned(byte op1, long op2)`
  `static int`
  `rightShiftUnsigned(byte op1, short op2)`
  `static int`
  `rightShiftUnsigned(int op1, byte op2)`
  `static int`
  `rightShiftUnsigned(int op1, int op2)`
  `static long`
  `rightShiftUnsigned(int op1, long op2)`
  `static int`
  `rightShiftUnsigned(int op1, short op2)`
  `static long`
  `rightShiftUnsigned(long op1, byte op2)`
  `static long`
  `rightShiftUnsigned(long op1, int op2)`
  `static long`
  `rightShiftUnsigned(long op1, long op2)`
  `static long`
  `rightShiftUnsigned(long op1, short op2)`
  `static int`
  `rightShiftUnsigned(short op1, byte op2)`
  `static int`
  `rightShiftUnsigned(short op1, int op2)`
  `static long`
  `rightShiftUnsigned(short op1, long op2)`
  `static int`
  `rightShiftUnsigned(short op1, short op2)`
  `static int`
  `xor(byte op1, byte op2)`
  `static int`
  `xor(byte op1, int op2)`
  `static long`
  `xor(byte op1, long op2)`
  `static int`
  `xor(byte op1, short op2)`
  `static int`
  `xor(int op1, byte op2)`
  `static int`
  `xor(int op1, int op2)`
  `static long`
  `xor(int op1, long op2)`
  `static int`
  `xor(int op1, short op2)`
  `static long`
  `xor(long op1, byte op2)`
  `static long`
  `xor(long op1, int op2)`
  `static long`
  `xor(long op1, long op2)`
  `static long`
  `xor(long op1, short op2)`
  `static int`
  `xor(short op1, byte op2)`
  `static int`
  `xor(short op1, int op2)`
  `static long`
  `xor(short op1, long op2)`
  `static int`
  `xor(short op1, short op2)`

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

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Field Details

  - ### instance

    public static final NumberMathModificationInfo instance

  - ### byte_plus

    public boolean byte_plus

  - ### short_plus

    public boolean short_plus

  - ### int_plus

    public boolean int_plus

  - ### long_plus

    public boolean long_plus

  - ### float_plus

    public boolean float_plus

  - ### double_plus

    public boolean double_plus

  - ### byte_minus

    public boolean byte_minus

  - ### short_minus

    public boolean short_minus

  - ### int_minus

    public boolean int_minus

  - ### long_minus

    public boolean long_minus

  - ### float_minus

    public boolean float_minus

  - ### double_minus

    public boolean double_minus

  - ### byte_multiply

    public boolean byte_multiply

  - ### short_multiply

    public boolean short_multiply

  - ### int_multiply

    public boolean int_multiply

  - ### long_multiply

    public boolean long_multiply

  - ### float_multiply

    public boolean float_multiply

  - ### double_multiply

    public boolean double_multiply

  - ### byte_div

    public boolean byte_div

  - ### short_div

    public boolean short_div

  - ### int_div

    public boolean int_div

  - ### long_div

    public boolean long_div

  - ### float_div

    public boolean float_div

  - ### double_div

    public boolean double_div

  - ### byte_or

    public boolean byte_or

  - ### short_or

    public boolean short_or

  - ### int_or

    public boolean int_or

  - ### long_or

    public boolean long_or

  - ### float_or

    public boolean float_or

  - ### double_or

    public boolean double_or

  - ### byte_and

    public boolean byte_and

  - ### short_and

    public boolean short_and

  - ### int_and

    public boolean int_and

  - ### long_and

    public boolean long_and

  - ### float_and

    public boolean float_and

  - ### double_and

    public boolean double_and

  - ### byte_xor

    public boolean byte_xor

  - ### short_xor

    public boolean short_xor

  - ### int_xor

    public boolean int_xor

  - ### long_xor

    public boolean long_xor

  - ### float_xor

    public boolean float_xor

  - ### double_xor

    public boolean double_xor

  - ### byte_intdiv

    public boolean byte_intdiv

  - ### short_intdiv

    public boolean short_intdiv

  - ### int_intdiv

    public boolean int_intdiv

  - ### long_intdiv

    public boolean long_intdiv

  - ### float_intdiv

    public boolean float_intdiv

  - ### double_intdiv

    public boolean double_intdiv

  - ### byte_mod

    public boolean byte_mod

  - ### short_mod

    public boolean short_mod

  - ### int_mod

    public boolean int_mod

  - ### long_mod

    public boolean long_mod

  - ### float_mod

    public boolean float_mod

  - ### double_mod

    public boolean double_mod

  - ### byte_leftShift

    public boolean byte_leftShift

  - ### short_leftShift

    public boolean short_leftShift

  - ### int_leftShift

    public boolean int_leftShift

  - ### long_leftShift

    public boolean long_leftShift

  - ### float_leftShift

    public boolean float_leftShift

  - ### double_leftShift

    public boolean double_leftShift

  - ### byte_rightShift

    public boolean byte_rightShift

  - ### short_rightShift

    public boolean short_rightShift

  - ### int_rightShift

    public boolean int_rightShift

  - ### long_rightShift

    public boolean long_rightShift

  - ### float_rightShift

    public boolean float_rightShift

  - ### double_rightShift

    public boolean double_rightShift

  - ### byte_rightShiftUnsigned

    public boolean byte_rightShiftUnsigned

  - ### short_rightShiftUnsigned

    public boolean short_rightShiftUnsigned

  - ### int_rightShiftUnsigned

    public boolean int_rightShiftUnsigned

  - ### long_rightShiftUnsigned

    public boolean long_rightShiftUnsigned

  - ### float_rightShiftUnsigned

    public boolean float_rightShiftUnsigned

  - ### double_rightShiftUnsigned

    public boolean double_rightShiftUnsigned

- ## Method Details

  - ### checkIfStdMethod

    public void checkIfStdMethod(MetaMethod method)

  - ### plus

    public static int plus(byte op1, byte op2)

  - ### plus

    public static int plus(byte op1, short op2)

  - ### plus

    public static int plus(byte op1, int op2)

  - ### plus

    public static long plus(byte op1, long op2)

  - ### plus

    public static double plus(byte op1, float op2)

  - ### plus

    public static double plus(byte op1, double op2)

  - ### plus

    public static int plus(short op1, byte op2)

  - ### plus

    public static int plus(short op1, short op2)

  - ### plus

    public static int plus(short op1, int op2)

  - ### plus

    public static long plus(short op1, long op2)

  - ### plus

    public static double plus(short op1, float op2)

  - ### plus

    public static double plus(short op1, double op2)

  - ### plus

    public static int plus(int op1, byte op2)

  - ### plus

    public static int plus(int op1, short op2)

  - ### plus

    public static int plus(int op1, int op2)

  - ### plus

    public static long plus(int op1, long op2)

  - ### plus

    public static double plus(int op1, float op2)

  - ### plus

    public static double plus(int op1, double op2)

  - ### plus

    public static long plus(long op1, byte op2)

  - ### plus

    public static long plus(long op1, short op2)

  - ### plus

    public static long plus(long op1, int op2)

  - ### plus

    public static long plus(long op1, long op2)

  - ### plus

    public static double plus(long op1, float op2)

  - ### plus

    public static double plus(long op1, double op2)

  - ### plus

    public static double plus(float op1, byte op2)

  - ### plus

    public static double plus(float op1, short op2)

  - ### plus

    public static double plus(float op1, int op2)

  - ### plus

    public static double plus(float op1, long op2)

  - ### plus

    public static double plus(float op1, float op2)

  - ### plus

    public static double plus(float op1, double op2)

  - ### plus

    public static double plus(double op1, byte op2)

  - ### plus

    public static double plus(double op1, short op2)

  - ### plus

    public static double plus(double op1, int op2)

  - ### plus

    public static double plus(double op1, long op2)

  - ### plus

    public static double plus(double op1, float op2)

  - ### plus

    public static double plus(double op1, double op2)

  - ### minus

    public static int minus(byte op1, byte op2)

  - ### minus

    public static int minus(byte op1, short op2)

  - ### minus

    public static int minus(byte op1, int op2)

  - ### minus

    public static long minus(byte op1, long op2)

  - ### minus

    public static double minus(byte op1, float op2)

  - ### minus

    public static double minus(byte op1, double op2)

  - ### minus

    public static int minus(short op1, byte op2)

  - ### minus

    public static int minus(short op1, short op2)

  - ### minus

    public static int minus(short op1, int op2)

  - ### minus

    public static long minus(short op1, long op2)

  - ### minus

    public static double minus(short op1, float op2)

  - ### minus

    public static double minus(short op1, double op2)

  - ### minus

    public static int minus(int op1, byte op2)

  - ### minus

    public static int minus(int op1, short op2)

  - ### minus

    public static int minus(int op1, int op2)

  - ### minus

    public static long minus(int op1, long op2)

  - ### minus

    public static double minus(int op1, float op2)

  - ### minus

    public static double minus(int op1, double op2)

  - ### minus

    public static long minus(long op1, byte op2)

  - ### minus

    public static long minus(long op1, short op2)

  - ### minus

    public static long minus(long op1, int op2)

  - ### minus

    public static long minus(long op1, long op2)

  - ### minus

    public static double minus(long op1, float op2)

  - ### minus

    public static double minus(long op1, double op2)

  - ### minus

    public static double minus(float op1, byte op2)

  - ### minus

    public static double minus(float op1, short op2)

  - ### minus

    public static double minus(float op1, int op2)

  - ### minus

    public static double minus(float op1, long op2)

  - ### minus

    public static double minus(float op1, float op2)

  - ### minus

    public static double minus(float op1, double op2)

  - ### minus

    public static double minus(double op1, byte op2)

  - ### minus

    public static double minus(double op1, short op2)

  - ### minus

    public static double minus(double op1, int op2)

  - ### minus

    public static double minus(double op1, long op2)

  - ### minus

    public static double minus(double op1, float op2)

  - ### minus

    public static double minus(double op1, double op2)

  - ### multiply

    public static int multiply(byte op1, byte op2)

  - ### multiply

    public static int multiply(byte op1, short op2)

  - ### multiply

    public static int multiply(byte op1, int op2)

  - ### multiply

    public static long multiply(byte op1, long op2)

  - ### multiply

    public static double multiply(byte op1, float op2)

  - ### multiply

    public static double multiply(byte op1, double op2)

  - ### multiply

    public static int multiply(short op1, byte op2)

  - ### multiply

    public static int multiply(short op1, short op2)

  - ### multiply

    public static int multiply(short op1, int op2)

  - ### multiply

    public static long multiply(short op1, long op2)

  - ### multiply

    public static double multiply(short op1, float op2)

  - ### multiply

    public static double multiply(short op1, double op2)

  - ### multiply

    public static int multiply(int op1, byte op2)

  - ### multiply

    public static int multiply(int op1, short op2)

  - ### multiply

    public static int multiply(int op1, int op2)

  - ### multiply

    public static long multiply(int op1, long op2)

  - ### multiply

    public static double multiply(int op1, float op2)

  - ### multiply

    public static double multiply(int op1, double op2)

  - ### multiply

    public static long multiply(long op1, byte op2)

  - ### multiply

    public static long multiply(long op1, short op2)

  - ### multiply

    public static long multiply(long op1, int op2)

  - ### multiply

    public static long multiply(long op1, long op2)

  - ### multiply

    public static double multiply(long op1, float op2)

  - ### multiply

    public static double multiply(long op1, double op2)

  - ### multiply

    public static double multiply(float op1, byte op2)

  - ### multiply

    public static double multiply(float op1, short op2)

  - ### multiply

    public static double multiply(float op1, int op2)

  - ### multiply

    public static double multiply(float op1, long op2)

  - ### multiply

    public static double multiply(float op1, float op2)

  - ### multiply

    public static double multiply(float op1, double op2)

  - ### multiply

    public static double multiply(double op1, byte op2)

  - ### multiply

    public static double multiply(double op1, short op2)

  - ### multiply

    public static double multiply(double op1, int op2)

  - ### multiply

    public static double multiply(double op1, long op2)

  - ### multiply

    public static double multiply(double op1, float op2)

  - ### multiply

    public static double multiply(double op1, double op2)

  - ### div

    public static int div(byte op1, byte op2)

  - ### div

    public static int div(byte op1, short op2)

  - ### div

    public static int div(byte op1, int op2)

  - ### div

    public static long div(byte op1, long op2)

  - ### div

    public static double div(byte op1, float op2)

  - ### div

    public static double div(byte op1, double op2)

  - ### div

    public static int div(short op1, byte op2)

  - ### div

    public static int div(short op1, short op2)

  - ### div

    public static int div(short op1, int op2)

  - ### div

    public static long div(short op1, long op2)

  - ### div

    public static double div(short op1, float op2)

  - ### div

    public static double div(short op1, double op2)

  - ### div

    public static int div(int op1, byte op2)

  - ### div

    public static int div(int op1, short op2)

  - ### div

    public static int div(int op1, int op2)

  - ### div

    public static long div(int op1, long op2)

  - ### div

    public static double div(int op1, float op2)

  - ### div

    public static double div(int op1, double op2)

  - ### div

    public static long div(long op1, byte op2)

  - ### div

    public static long div(long op1, short op2)

  - ### div

    public static long div(long op1, int op2)

  - ### div

    public static long div(long op1, long op2)

  - ### div

    public static double div(long op1, float op2)

  - ### div

    public static double div(long op1, double op2)

  - ### div

    public static double div(float op1, byte op2)

  - ### div

    public static double div(float op1, short op2)

  - ### div

    public static double div(float op1, int op2)

  - ### div

    public static double div(float op1, long op2)

  - ### div

    public static double div(float op1, float op2)

  - ### div

    public static double div(float op1, double op2)

  - ### div

    public static double div(double op1, byte op2)

  - ### div

    public static double div(double op1, short op2)

  - ### div

    public static double div(double op1, int op2)

  - ### div

    public static double div(double op1, long op2)

  - ### div

    public static double div(double op1, float op2)

  - ### div

    public static double div(double op1, double op2)

  - ### or

    public static int or(byte op1, byte op2)

  - ### or

    public static int or(byte op1, short op2)

  - ### or

    public static int or(byte op1, int op2)

  - ### or

    public static long or(byte op1, long op2)

  - ### or

    public static int or(short op1, byte op2)

  - ### or

    public static int or(short op1, short op2)

  - ### or

    public static int or(short op1, int op2)

  - ### or

    public static long or(short op1, long op2)

  - ### or

    public static int or(int op1, byte op2)

  - ### or

    public static int or(int op1, short op2)

  - ### or

    public static int or(int op1, int op2)

  - ### or

    public static long or(int op1, long op2)

  - ### or

    public static long or(long op1, byte op2)

  - ### or

    public static long or(long op1, short op2)

  - ### or

    public static long or(long op1, int op2)

  - ### or

    public static long or(long op1, long op2)

  - ### and

    public static int and(byte op1, byte op2)

  - ### and

    public static int and(byte op1, short op2)

  - ### and

    public static int and(byte op1, int op2)

  - ### and

    public static long and(byte op1, long op2)

  - ### and

    public static int and(short op1, byte op2)

  - ### and

    public static int and(short op1, short op2)

  - ### and

    public static int and(short op1, int op2)

  - ### and

    public static long and(short op1, long op2)

  - ### and

    public static int and(int op1, byte op2)

  - ### and

    public static int and(int op1, short op2)

  - ### and

    public static int and(int op1, int op2)

  - ### and

    public static long and(int op1, long op2)

  - ### and

    public static long and(long op1, byte op2)

  - ### and

    public static long and(long op1, short op2)

  - ### and

    public static long and(long op1, int op2)

  - ### and

    public static long and(long op1, long op2)

  - ### xor

    public static int xor(byte op1, byte op2)

  - ### xor

    public static int xor(byte op1, short op2)

  - ### xor

    public static int xor(byte op1, int op2)

  - ### xor

    public static long xor(byte op1, long op2)

  - ### xor

    public static int xor(short op1, byte op2)

  - ### xor

    public static int xor(short op1, short op2)

  - ### xor

    public static int xor(short op1, int op2)

  - ### xor

    public static long xor(short op1, long op2)

  - ### xor

    public static int xor(int op1, byte op2)

  - ### xor

    public static int xor(int op1, short op2)

  - ### xor

    public static int xor(int op1, int op2)

  - ### xor

    public static long xor(int op1, long op2)

  - ### xor

    public static long xor(long op1, byte op2)

  - ### xor

    public static long xor(long op1, short op2)

  - ### xor

    public static long xor(long op1, int op2)

  - ### xor

    public static long xor(long op1, long op2)

  - ### intdiv

    public static int intdiv(byte op1, byte op2)

  - ### intdiv

    public static int intdiv(byte op1, short op2)

  - ### intdiv

    public static int intdiv(byte op1, int op2)

  - ### intdiv

    public static long intdiv(byte op1, long op2)

  - ### intdiv

    public static int intdiv(short op1, byte op2)

  - ### intdiv

    public static int intdiv(short op1, short op2)

  - ### intdiv

    public static int intdiv(short op1, int op2)

  - ### intdiv

    public static long intdiv(short op1, long op2)

  - ### intdiv

    public static int intdiv(int op1, byte op2)

  - ### intdiv

    public static int intdiv(int op1, short op2)

  - ### intdiv

    public static int intdiv(int op1, int op2)

  - ### intdiv

    public static long intdiv(int op1, long op2)

  - ### intdiv

    public static long intdiv(long op1, byte op2)

  - ### intdiv

    public static long intdiv(long op1, short op2)

  - ### intdiv

    public static long intdiv(long op1, int op2)

  - ### intdiv

    public static long intdiv(long op1, long op2)

  - ### mod

    public static int mod(byte op1, byte op2)

  - ### mod

    public static int mod(byte op1, short op2)

  - ### mod

    public static int mod(byte op1, int op2)

  - ### mod

    public static long mod(byte op1, long op2)

  - ### mod

    public static int mod(short op1, byte op2)

  - ### mod

    public static int mod(short op1, short op2)

  - ### mod

    public static int mod(short op1, int op2)

  - ### mod

    public static long mod(short op1, long op2)

  - ### mod

    public static int mod(int op1, byte op2)

  - ### mod

    public static int mod(int op1, short op2)

  - ### mod

    public static int mod(int op1, int op2)

  - ### mod

    public static long mod(int op1, long op2)

  - ### mod

    public static long mod(long op1, byte op2)

  - ### mod

    public static long mod(long op1, short op2)

  - ### mod

    public static long mod(long op1, int op2)

  - ### mod

    public static long mod(long op1, long op2)

  - ### leftShift

    public static int leftShift(byte op1, byte op2)

  - ### leftShift

    public static int leftShift(byte op1, short op2)

  - ### leftShift

    public static int leftShift(byte op1, int op2)

  - ### leftShift

    public static long leftShift(byte op1, long op2)

  - ### leftShift

    public static int leftShift(short op1, byte op2)

  - ### leftShift

    public static int leftShift(short op1, short op2)

  - ### leftShift

    public static int leftShift(short op1, int op2)

  - ### leftShift

    public static long leftShift(short op1, long op2)

  - ### leftShift

    public static int leftShift(int op1, byte op2)

  - ### leftShift

    public static int leftShift(int op1, short op2)

  - ### leftShift

    public static int leftShift(int op1, int op2)

  - ### leftShift

    public static long leftShift(int op1, long op2)

  - ### leftShift

    public static long leftShift(long op1, byte op2)

  - ### leftShift

    public static long leftShift(long op1, short op2)

  - ### leftShift

    public static long leftShift(long op1, int op2)

  - ### leftShift

    public static long leftShift(long op1, long op2)

  - ### rightShift

    public static int rightShift(byte op1, byte op2)

  - ### rightShift

    public static int rightShift(byte op1, short op2)

  - ### rightShift

    public static int rightShift(byte op1, int op2)

  - ### rightShift

    public static long rightShift(byte op1, long op2)

  - ### rightShift

    public static int rightShift(short op1, byte op2)

  - ### rightShift

    public static int rightShift(short op1, short op2)

  - ### rightShift

    public static int rightShift(short op1, int op2)

  - ### rightShift

    public static long rightShift(short op1, long op2)

  - ### rightShift

    public static int rightShift(int op1, byte op2)

  - ### rightShift

    public static int rightShift(int op1, short op2)

  - ### rightShift

    public static int rightShift(int op1, int op2)

  - ### rightShift

    public static long rightShift(int op1, long op2)

  - ### rightShift

    public static long rightShift(long op1, byte op2)

  - ### rightShift

    public static long rightShift(long op1, short op2)

  - ### rightShift

    public static long rightShift(long op1, int op2)

  - ### rightShift

    public static long rightShift(long op1, long op2)

  - ### rightShiftUnsigned

    public static int rightShiftUnsigned(byte op1, byte op2)

  - ### rightShiftUnsigned

    public static int rightShiftUnsigned(byte op1, short op2)

  - ### rightShiftUnsigned

    public static int rightShiftUnsigned(byte op1, int op2)

  - ### rightShiftUnsigned

    public static long rightShiftUnsigned(byte op1, long op2)

  - ### rightShiftUnsigned

    public static int rightShiftUnsigned(short op1, byte op2)

  - ### rightShiftUnsigned

    public static int rightShiftUnsigned(short op1, short op2)

  - ### rightShiftUnsigned

    public static int rightShiftUnsigned(short op1, int op2)

  - ### rightShiftUnsigned

    public static long rightShiftUnsigned(short op1, long op2)

  - ### rightShiftUnsigned

    public static int rightShiftUnsigned(int op1, byte op2)

  - ### rightShiftUnsigned

    public static int rightShiftUnsigned(int op1, short op2)

  - ### rightShiftUnsigned

    public static int rightShiftUnsigned(int op1, int op2)

  - ### rightShiftUnsigned

    public static long rightShiftUnsigned(int op1, long op2)

  - ### rightShiftUnsigned

    public static long rightShiftUnsigned(long op1, byte op2)

  - ### rightShiftUnsigned

    public static long rightShiftUnsigned(long op1, short op2)

  - ### rightShiftUnsigned

    public static long rightShiftUnsigned(long op1, int op2)

  - ### rightShiftUnsigned

    public static long rightShiftUnsigned(long op1, long op2)