Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.codehaus.groovy.runtime.typehandling
Class NumberMathModificationInfo

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

    public class NumberMathModificationInfo
    extends Object

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

Method Summary
Modifier and Type | Method and 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 Detail

### 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 Detail

### 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)

Overview | Package | Class | Tree | Deprecated | Index | Help
| Copyright © 2003-2010 The Codehaus. All rights reserved.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD