java.lang.Object

org.codehaus.groovy.runtime.typehandling.NumberMathModificationInfo

public class NumberMathModificationInfo
extends java.lang.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

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)

Class NumberMathModificationInfo

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Details

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 Details

checkIfStdMethod