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

All Methods Static Methods Instance Methods Concrete Methods
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 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)

Class NumberMathModificationInfo

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

instance

byte_plus

short_plus

int_plus

long_plus

float_plus

double_plus

byte_minus

short_minus

int_minus

long_minus

float_minus

double_minus

byte_multiply

short_multiply

int_multiply

long_multiply

float_multiply

double_multiply

byte_div

short_div

int_div

long_div

float_div

double_div

byte_or

short_or

int_or

long_or

float_or

double_or

byte_and

short_and

int_and

long_and

float_and

double_and

byte_xor

short_xor

int_xor

long_xor

float_xor

double_xor

byte_intdiv

short_intdiv

int_intdiv

long_intdiv

float_intdiv

double_intdiv

byte_mod

short_mod

int_mod

long_mod

float_mod

double_mod

byte_leftShift

short_leftShift

int_leftShift

long_leftShift

float_leftShift

double_leftShift

byte_rightShift

short_rightShift

int_rightShift

long_rightShift

float_rightShift

double_rightShift

byte_rightShiftUnsigned

short_rightShiftUnsigned

int_rightShiftUnsigned

long_rightShiftUnsigned

float_rightShiftUnsigned

double_rightShiftUnsigned

Method Detail

checkIfStdMethod