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)