org.codehaus.groovy.runtime.typehandling
Class NumberMathModificationInfo

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

public class NumberMathModificationInfo
extends java.lang.Object


Field Summary
 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
           
private  java.util.HashSet<java.lang.String> names
           
 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
           
 
Constructor Summary
private NumberMathModificationInfo()
           
 
Method Summary
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)
           
private static int andSlow(byte op1, byte op2)
           
private static int andSlow(byte op1, int op2)
           
private static long andSlow(byte op1, long op2)
           
private static int andSlow(byte op1, short op2)
           
private static int andSlow(int op1, byte op2)
           
private static int andSlow(int op1, int op2)
           
private static long andSlow(int op1, long op2)
           
private static int andSlow(int op1, short op2)
           
private static long andSlow(long op1, byte op2)
           
private static long andSlow(long op1, int op2)
           
private static long andSlow(long op1, long op2)
           
private static long andSlow(long op1, short op2)
           
private static int andSlow(short op1, byte op2)
           
private static int andSlow(short op1, int op2)
           
private static long andSlow(short op1, long op2)
           
private static int andSlow(short op1, short op2)
           
 void checkIfStdMethod(MetaMethod method)
           
private  void checkNumberOps(java.lang.String name, java.lang.Class klazz)
           
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)
           
private static int divSlow(byte op1, byte op2)
           
private static double divSlow(byte op1, double op2)
           
private static double divSlow(byte op1, float op2)
           
private static int divSlow(byte op1, int op2)
           
private static long divSlow(byte op1, long op2)
           
private static int divSlow(byte op1, short op2)
           
private static double divSlow(double op1, byte op2)
           
private static double divSlow(double op1, double op2)
           
private static double divSlow(double op1, float op2)
           
private static double divSlow(double op1, int op2)
           
private static double divSlow(double op1, long op2)
           
private static double divSlow(double op1, short op2)
           
private static double divSlow(float op1, byte op2)
           
private static double divSlow(float op1, double op2)
           
private static double divSlow(float op1, float op2)
           
private static double divSlow(float op1, int op2)
           
private static double divSlow(float op1, long op2)
           
private static double divSlow(float op1, short op2)
           
private static int divSlow(int op1, byte op2)
           
private static double divSlow(int op1, double op2)
           
private static double divSlow(int op1, float op2)
           
private static int divSlow(int op1, int op2)
           
private static long divSlow(int op1, long op2)
           
private static int divSlow(int op1, short op2)
           
private static long divSlow(long op1, byte op2)
           
private static double divSlow(long op1, double op2)
           
private static double divSlow(long op1, float op2)
           
private static long divSlow(long op1, int op2)
           
private static long divSlow(long op1, long op2)
           
private static long divSlow(long op1, short op2)
           
private static int divSlow(short op1, byte op2)
           
private static double divSlow(short op1, double op2)
           
private static double divSlow(short op1, float op2)
           
private static int divSlow(short op1, int op2)
           
private static long divSlow(short op1, long op2)
           
private static int divSlow(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)
           
private static int intdivSlow(byte op1, byte op2)
           
private static int intdivSlow(byte op1, int op2)
           
private static long intdivSlow(byte op1, long op2)
           
private static int intdivSlow(byte op1, short op2)
           
private static int intdivSlow(int op1, byte op2)
           
private static int intdivSlow(int op1, int op2)
           
private static long intdivSlow(int op1, long op2)
           
private static int intdivSlow(int op1, short op2)
           
private static long intdivSlow(long op1, byte op2)
           
private static long intdivSlow(long op1, int op2)
           
private static long intdivSlow(long op1, long op2)
           
private static long intdivSlow(long op1, short op2)
           
private static int intdivSlow(short op1, byte op2)
           
private static int intdivSlow(short op1, int op2)
           
private static long intdivSlow(short op1, long op2)
           
private static int intdivSlow(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)
           
private static int leftShiftSlow(byte op1, byte op2)
           
private static int leftShiftSlow(byte op1, int op2)
           
private static long leftShiftSlow(byte op1, long op2)
           
private static int leftShiftSlow(byte op1, short op2)
           
private static int leftShiftSlow(int op1, byte op2)
           
private static int leftShiftSlow(int op1, int op2)
           
private static long leftShiftSlow(int op1, long op2)
           
private static int leftShiftSlow(int op1, short op2)
           
private static long leftShiftSlow(long op1, byte op2)
           
private static long leftShiftSlow(long op1, int op2)
           
private static long leftShiftSlow(long op1, long op2)
           
private static long leftShiftSlow(long op1, short op2)
           
private static int leftShiftSlow(short op1, byte op2)
           
private static int leftShiftSlow(short op1, int op2)
           
private static long leftShiftSlow(short op1, long op2)
           
private static int leftShiftSlow(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)
           
private static int minusSlow(byte op1, byte op2)
           
private static double minusSlow(byte op1, double op2)
           
private static double minusSlow(byte op1, float op2)
           
private static int minusSlow(byte op1, int op2)
           
private static long minusSlow(byte op1, long op2)
           
private static int minusSlow(byte op1, short op2)
           
private static double minusSlow(double op1, byte op2)
           
private static double minusSlow(double op1, double op2)
           
private static double minusSlow(double op1, float op2)
           
private static double minusSlow(double op1, int op2)
           
private static double minusSlow(double op1, long op2)
           
private static double minusSlow(double op1, short op2)
           
private static double minusSlow(float op1, byte op2)
           
private static double minusSlow(float op1, double op2)
           
private static double minusSlow(float op1, float op2)
           
private static double minusSlow(float op1, int op2)
           
private static double minusSlow(float op1, long op2)
           
private static double minusSlow(float op1, short op2)
           
private static int minusSlow(int op1, byte op2)
           
private static double minusSlow(int op1, double op2)
           
private static double minusSlow(int op1, float op2)
           
private static int minusSlow(int op1, int op2)
           
private static long minusSlow(int op1, long op2)
           
private static int minusSlow(int op1, short op2)
           
private static long minusSlow(long op1, byte op2)
           
private static double minusSlow(long op1, double op2)
           
private static double minusSlow(long op1, float op2)
           
private static long minusSlow(long op1, int op2)
           
private static long minusSlow(long op1, long op2)
           
private static long minusSlow(long op1, short op2)
           
private static int minusSlow(short op1, byte op2)
           
private static double minusSlow(short op1, double op2)
           
private static double minusSlow(short op1, float op2)
           
private static int minusSlow(short op1, int op2)
           
private static long minusSlow(short op1, long op2)
           
private static int minusSlow(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)
           
private static int modSlow(byte op1, byte op2)
           
private static int modSlow(byte op1, int op2)
           
private static long modSlow(byte op1, long op2)
           
private static int modSlow(byte op1, short op2)
           
private static int modSlow(int op1, byte op2)
           
private static int modSlow(int op1, int op2)
           
private static long modSlow(int op1, long op2)
           
private static int modSlow(int op1, short op2)
           
private static long modSlow(long op1, byte op2)
           
private static long modSlow(long op1, int op2)
           
private static long modSlow(long op1, long op2)
           
private static long modSlow(long op1, short op2)
           
private static int modSlow(short op1, byte op2)
           
private static int modSlow(short op1, int op2)
           
private static long modSlow(short op1, long op2)
           
private static int modSlow(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)
           
private static int multiplySlow(byte op1, byte op2)
           
private static double multiplySlow(byte op1, double op2)
           
private static double multiplySlow(byte op1, float op2)
           
private static int multiplySlow(byte op1, int op2)
           
private static long multiplySlow(byte op1, long op2)
           
private static int multiplySlow(byte op1, short op2)
           
private static double multiplySlow(double op1, byte op2)
           
private static double multiplySlow(double op1, double op2)
           
private static double multiplySlow(double op1, float op2)
           
private static double multiplySlow(double op1, int op2)
           
private static double multiplySlow(double op1, long op2)
           
private static double multiplySlow(double op1, short op2)
           
private static double multiplySlow(float op1, byte op2)
           
private static double multiplySlow(float op1, double op2)
           
private static double multiplySlow(float op1, float op2)
           
private static double multiplySlow(float op1, int op2)
           
private static double multiplySlow(float op1, long op2)
           
private static double multiplySlow(float op1, short op2)
           
private static int multiplySlow(int op1, byte op2)
           
private static double multiplySlow(int op1, double op2)
           
private static double multiplySlow(int op1, float op2)
           
private static int multiplySlow(int op1, int op2)
           
private static long multiplySlow(int op1, long op2)
           
private static int multiplySlow(int op1, short op2)
           
private static long multiplySlow(long op1, byte op2)
           
private static double multiplySlow(long op1, double op2)
           
private static double multiplySlow(long op1, float op2)
           
private static long multiplySlow(long op1, int op2)
           
private static long multiplySlow(long op1, long op2)
           
private static long multiplySlow(long op1, short op2)
           
private static int multiplySlow(short op1, byte op2)
           
private static double multiplySlow(short op1, double op2)
           
private static double multiplySlow(short op1, float op2)
           
private static int multiplySlow(short op1, int op2)
           
private static long multiplySlow(short op1, long op2)
           
private static int multiplySlow(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)
           
private static int orSlow(byte op1, byte op2)
           
private static int orSlow(byte op1, int op2)
           
private static long orSlow(byte op1, long op2)
           
private static int orSlow(byte op1, short op2)
           
private static int orSlow(int op1, byte op2)
           
private static int orSlow(int op1, int op2)
           
private static long orSlow(int op1, long op2)
           
private static int orSlow(int op1, short op2)
           
private static long orSlow(long op1, byte op2)
           
private static long orSlow(long op1, int op2)
           
private static long orSlow(long op1, long op2)
           
private static long orSlow(long op1, short op2)
           
private static int orSlow(short op1, byte op2)
           
private static int orSlow(short op1, int op2)
           
private static long orSlow(short op1, long op2)
           
private static int orSlow(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)
           
private static int plusSlow(byte op1, byte op2)
           
private static double plusSlow(byte op1, double op2)
           
private static double plusSlow(byte op1, float op2)
           
private static int plusSlow(byte op1, int op2)
           
private static long plusSlow(byte op1, long op2)
           
private static int plusSlow(byte op1, short op2)
           
private static double plusSlow(double op1, byte op2)
           
private static double plusSlow(double op1, double op2)
           
private static double plusSlow(double op1, float op2)
           
private static double plusSlow(double op1, int op2)
           
private static double plusSlow(double op1, long op2)
           
private static double plusSlow(double op1, short op2)
           
private static double plusSlow(float op1, byte op2)
           
private static double plusSlow(float op1, double op2)
           
private static double plusSlow(float op1, float op2)
           
private static double plusSlow(float op1, int op2)
           
private static double plusSlow(float op1, long op2)
           
private static double plusSlow(float op1, short op2)
           
private static int plusSlow(int op1, byte op2)
           
private static double plusSlow(int op1, double op2)
           
private static double plusSlow(int op1, float op2)
           
private static int plusSlow(int op1, int op2)
           
private static long plusSlow(int op1, long op2)
           
private static int plusSlow(int op1, short op2)
           
private static long plusSlow(long op1, byte op2)
           
private static double plusSlow(long op1, double op2)
           
private static double plusSlow(long op1, float op2)
           
private static long plusSlow(long op1, int op2)
           
private static long plusSlow(long op1, long op2)
           
private static long plusSlow(long op1, short op2)
           
private static int plusSlow(short op1, byte op2)
           
private static double plusSlow(short op1, double op2)
           
private static double plusSlow(short op1, float op2)
           
private static int plusSlow(short op1, int op2)
           
private static long plusSlow(short op1, long op2)
           
private static int plusSlow(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)
           
private static int rightShiftSlow(byte op1, byte op2)
           
private static int rightShiftSlow(byte op1, int op2)
           
private static long rightShiftSlow(byte op1, long op2)
           
private static int rightShiftSlow(byte op1, short op2)
           
private static int rightShiftSlow(int op1, byte op2)
           
private static int rightShiftSlow(int op1, int op2)
           
private static long rightShiftSlow(int op1, long op2)
           
private static int rightShiftSlow(int op1, short op2)
           
private static long rightShiftSlow(long op1, byte op2)
           
private static long rightShiftSlow(long op1, int op2)
           
private static long rightShiftSlow(long op1, long op2)
           
private static long rightShiftSlow(long op1, short op2)
           
private static int rightShiftSlow(short op1, byte op2)
           
private static int rightShiftSlow(short op1, int op2)
           
private static long rightShiftSlow(short op1, long op2)
           
private static int rightShiftSlow(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)
           
private static int rightShiftUnsignedSlow(byte op1, byte op2)
           
private static int rightShiftUnsignedSlow(byte op1, int op2)
           
private static long rightShiftUnsignedSlow(byte op1, long op2)
           
private static int rightShiftUnsignedSlow(byte op1, short op2)
           
private static int rightShiftUnsignedSlow(int op1, byte op2)
           
private static int rightShiftUnsignedSlow(int op1, int op2)
           
private static long rightShiftUnsignedSlow(int op1, long op2)
           
private static int rightShiftUnsignedSlow(int op1, short op2)
           
private static long rightShiftUnsignedSlow(long op1, byte op2)
           
private static long rightShiftUnsignedSlow(long op1, int op2)
           
private static long rightShiftUnsignedSlow(long op1, long op2)
           
private static long rightShiftUnsignedSlow(long op1, short op2)
           
private static int rightShiftUnsignedSlow(short op1, byte op2)
           
private static int rightShiftUnsignedSlow(short op1, int op2)
           
private static long rightShiftUnsignedSlow(short op1, long op2)
           
private static int rightShiftUnsignedSlow(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)
           
private static int xorSlow(byte op1, byte op2)
           
private static int xorSlow(byte op1, int op2)
           
private static long xorSlow(byte op1, long op2)
           
private static int xorSlow(byte op1, short op2)
           
private static int xorSlow(int op1, byte op2)
           
private static int xorSlow(int op1, int op2)
           
private static long xorSlow(int op1, long op2)
           
private static int xorSlow(int op1, short op2)
           
private static long xorSlow(long op1, byte op2)
           
private static long xorSlow(long op1, int op2)
           
private static long xorSlow(long op1, long op2)
           
private static long xorSlow(long op1, short op2)
           
private static int xorSlow(short op1, byte op2)
           
private static int xorSlow(short op1, int op2)
           
private static long xorSlow(short op1, long op2)
           
private static int xorSlow(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

names

private final java.util.HashSet<java.lang.String> names

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

NumberMathModificationInfo

private NumberMathModificationInfo()
Method Detail

checkIfStdMethod

public void checkIfStdMethod(MetaMethod method)

checkNumberOps

private void checkNumberOps(java.lang.String name,
                            java.lang.Class klazz)

plus

public static int plus(byte op1,
                       byte op2)

plusSlow

private static int plusSlow(byte op1,
                            byte op2)

plus

public static int plus(byte op1,
                       short op2)

plusSlow

private static int plusSlow(byte op1,
                            short op2)

plus

public static int plus(byte op1,
                       int op2)

plusSlow

private static int plusSlow(byte op1,
                            int op2)

plus

public static long plus(byte op1,
                        long op2)

plusSlow

private static long plusSlow(byte op1,
                             long op2)

plus

public static double plus(byte op1,
                          float op2)

plusSlow

private static double plusSlow(byte op1,
                               float op2)

plus

public static double plus(byte op1,
                          double op2)

plusSlow

private static double plusSlow(byte op1,
                               double op2)

plus

public static int plus(short op1,
                       byte op2)

plusSlow

private static int plusSlow(short op1,
                            byte op2)

plus

public static int plus(short op1,
                       short op2)

plusSlow

private static int plusSlow(short op1,
                            short op2)

plus

public static int plus(short op1,
                       int op2)

plusSlow

private static int plusSlow(short op1,
                            int op2)

plus

public static long plus(short op1,
                        long op2)

plusSlow

private static long plusSlow(short op1,
                             long op2)

plus

public static double plus(short op1,
                          float op2)

plusSlow

private static double plusSlow(short op1,
                               float op2)

plus

public static double plus(short op1,
                          double op2)

plusSlow

private static double plusSlow(short op1,
                               double op2)

plus

public static int plus(int op1,
                       byte op2)

plusSlow

private static int plusSlow(int op1,
                            byte op2)

plus

public static int plus(int op1,
                       short op2)

plusSlow

private static int plusSlow(int op1,
                            short op2)

plus

public static int plus(int op1,
                       int op2)

plusSlow

private static int plusSlow(int op1,
                            int op2)

plus

public static long plus(int op1,
                        long op2)

plusSlow

private static long plusSlow(int op1,
                             long op2)

plus

public static double plus(int op1,
                          float op2)

plusSlow

private static double plusSlow(int op1,
                               float op2)

plus

public static double plus(int op1,
                          double op2)

plusSlow

private static double plusSlow(int op1,
                               double op2)

plus

public static long plus(long op1,
                        byte op2)

plusSlow

private static long plusSlow(long op1,
                             byte op2)

plus

public static long plus(long op1,
                        short op2)

plusSlow

private static long plusSlow(long op1,
                             short op2)

plus

public static long plus(long op1,
                        int op2)

plusSlow

private static long plusSlow(long op1,
                             int op2)

plus

public static long plus(long op1,
                        long op2)

plusSlow

private static long plusSlow(long op1,
                             long op2)

plus

public static double plus(long op1,
                          float op2)

plusSlow

private static double plusSlow(long op1,
                               float op2)

plus

public static double plus(long op1,
                          double op2)

plusSlow

private static double plusSlow(long op1,
                               double op2)

plus

public static double plus(float op1,
                          byte op2)

plusSlow

private static double plusSlow(float op1,
                               byte op2)

plus

public static double plus(float op1,
                          short op2)

plusSlow

private static double plusSlow(float op1,
                               short op2)

plus

public static double plus(float op1,
                          int op2)

plusSlow

private static double plusSlow(float op1,
                               int op2)

plus

public static double plus(float op1,
                          long op2)

plusSlow

private static double plusSlow(float op1,
                               long op2)

plus

public static double plus(float op1,
                          float op2)

plusSlow

private static double plusSlow(float op1,
                               float op2)

plus

public static double plus(float op1,
                          double op2)

plusSlow

private static double plusSlow(float op1,
                               double op2)

plus

public static double plus(double op1,
                          byte op2)

plusSlow

private static double plusSlow(double op1,
                               byte op2)

plus

public static double plus(double op1,
                          short op2)

plusSlow

private static double plusSlow(double op1,
                               short op2)

plus

public static double plus(double op1,
                          int op2)

plusSlow

private static double plusSlow(double op1,
                               int op2)

plus

public static double plus(double op1,
                          long op2)

plusSlow

private static double plusSlow(double op1,
                               long op2)

plus

public static double plus(double op1,
                          float op2)

plusSlow

private static double plusSlow(double op1,
                               float op2)

plus

public static double plus(double op1,
                          double op2)

plusSlow

private static double plusSlow(double op1,
                               double op2)

minus

public static int minus(byte op1,
                        byte op2)

minusSlow

private static int minusSlow(byte op1,
                             byte op2)

minus

public static int minus(byte op1,
                        short op2)

minusSlow

private static int minusSlow(byte op1,
                             short op2)

minus

public static int minus(byte op1,
                        int op2)

minusSlow

private static int minusSlow(byte op1,
                             int op2)

minus

public static long minus(byte op1,
                         long op2)

minusSlow

private static long minusSlow(byte op1,
                              long op2)

minus

public static double minus(byte op1,
                           float op2)

minusSlow

private static double minusSlow(byte op1,
                                float op2)

minus

public static double minus(byte op1,
                           double op2)

minusSlow

private static double minusSlow(byte op1,
                                double op2)

minus

public static int minus(short op1,
                        byte op2)

minusSlow

private static int minusSlow(short op1,
                             byte op2)

minus

public static int minus(short op1,
                        short op2)

minusSlow

private static int minusSlow(short op1,
                             short op2)

minus

public static int minus(short op1,
                        int op2)

minusSlow

private static int minusSlow(short op1,
                             int op2)

minus

public static long minus(short op1,
                         long op2)

minusSlow

private static long minusSlow(short op1,
                              long op2)

minus

public static double minus(short op1,
                           float op2)

minusSlow

private static double minusSlow(short op1,
                                float op2)

minus

public static double minus(short op1,
                           double op2)

minusSlow

private static double minusSlow(short op1,
                                double op2)

minus

public static int minus(int op1,
                        byte op2)

minusSlow

private static int minusSlow(int op1,
                             byte op2)

minus

public static int minus(int op1,
                        short op2)

minusSlow

private static int minusSlow(int op1,
                             short op2)

minus

public static int minus(int op1,
                        int op2)

minusSlow

private static int minusSlow(int op1,
                             int op2)

minus

public static long minus(int op1,
                         long op2)

minusSlow

private static long minusSlow(int op1,
                              long op2)

minus

public static double minus(int op1,
                           float op2)

minusSlow

private static double minusSlow(int op1,
                                float op2)

minus

public static double minus(int op1,
                           double op2)

minusSlow

private static double minusSlow(int op1,
                                double op2)

minus

public static long minus(long op1,
                         byte op2)

minusSlow

private static long minusSlow(long op1,
                              byte op2)

minus

public static long minus(long op1,
                         short op2)

minusSlow

private static long minusSlow(long op1,
                              short op2)

minus

public static long minus(long op1,
                         int op2)

minusSlow

private static long minusSlow(long op1,
                              int op2)

minus

public static long minus(long op1,
                         long op2)

minusSlow

private static long minusSlow(long op1,
                              long op2)

minus

public static double minus(long op1,
                           float op2)

minusSlow

private static double minusSlow(long op1,
                                float op2)

minus

public static double minus(long op1,
                           double op2)

minusSlow

private static double minusSlow(long op1,
                                double op2)

minus

public static double minus(float op1,
                           byte op2)

minusSlow

private static double minusSlow(float op1,
                                byte op2)

minus

public static double minus(float op1,
                           short op2)

minusSlow

private static double minusSlow(float op1,
                                short op2)

minus

public static double minus(float op1,
                           int op2)

minusSlow

private static double minusSlow(float op1,
                                int op2)

minus

public static double minus(float op1,
                           long op2)

minusSlow

private static double minusSlow(float op1,
                                long op2)

minus

public static double minus(float op1,
                           float op2)

minusSlow

private static double minusSlow(float op1,
                                float op2)

minus

public static double minus(float op1,
                           double op2)

minusSlow

private static double minusSlow(float op1,
                                double op2)

minus

public static double minus(double op1,
                           byte op2)

minusSlow

private static double minusSlow(double op1,
                                byte op2)

minus

public static double minus(double op1,
                           short op2)

minusSlow

private static double minusSlow(double op1,
                                short op2)

minus

public static double minus(double op1,
                           int op2)

minusSlow

private static double minusSlow(double op1,
                                int op2)

minus

public static double minus(double op1,
                           long op2)

minusSlow

private static double minusSlow(double op1,
                                long op2)

minus

public static double minus(double op1,
                           float op2)

minusSlow

private static double minusSlow(double op1,
                                float op2)

minus

public static double minus(double op1,
                           double op2)

minusSlow

private static double minusSlow(double op1,
                                double op2)

multiply

public static int multiply(byte op1,
                           byte op2)

multiplySlow

private static int multiplySlow(byte op1,
                                byte op2)

multiply

public static int multiply(byte op1,
                           short op2)

multiplySlow

private static int multiplySlow(byte op1,
                                short op2)

multiply

public static int multiply(byte op1,
                           int op2)

multiplySlow

private static int multiplySlow(byte op1,
                                int op2)

multiply

public static long multiply(byte op1,
                            long op2)

multiplySlow

private static long multiplySlow(byte op1,
                                 long op2)

multiply

public static double multiply(byte op1,
                              float op2)

multiplySlow

private static double multiplySlow(byte op1,
                                   float op2)

multiply

public static double multiply(byte op1,
                              double op2)

multiplySlow

private static double multiplySlow(byte op1,
                                   double op2)

multiply

public static int multiply(short op1,
                           byte op2)

multiplySlow

private static int multiplySlow(short op1,
                                byte op2)

multiply

public static int multiply(short op1,
                           short op2)

multiplySlow

private static int multiplySlow(short op1,
                                short op2)

multiply

public static int multiply(short op1,
                           int op2)

multiplySlow

private static int multiplySlow(short op1,
                                int op2)

multiply

public static long multiply(short op1,
                            long op2)

multiplySlow

private static long multiplySlow(short op1,
                                 long op2)

multiply

public static double multiply(short op1,
                              float op2)

multiplySlow

private static double multiplySlow(short op1,
                                   float op2)

multiply

public static double multiply(short op1,
                              double op2)

multiplySlow

private static double multiplySlow(short op1,
                                   double op2)

multiply

public static int multiply(int op1,
                           byte op2)

multiplySlow

private static int multiplySlow(int op1,
                                byte op2)

multiply

public static int multiply(int op1,
                           short op2)

multiplySlow

private static int multiplySlow(int op1,
                                short op2)

multiply

public static int multiply(int op1,
                           int op2)

multiplySlow

private static int multiplySlow(int op1,
                                int op2)

multiply

public static long multiply(int op1,
                            long op2)

multiplySlow

private static long multiplySlow(int op1,
                                 long op2)

multiply

public static double multiply(int op1,
                              float op2)

multiplySlow

private static double multiplySlow(int op1,
                                   float op2)

multiply

public static double multiply(int op1,
                              double op2)

multiplySlow

private static double multiplySlow(int op1,
                                   double op2)

multiply

public static long multiply(long op1,
                            byte op2)

multiplySlow

private static long multiplySlow(long op1,
                                 byte op2)

multiply

public static long multiply(long op1,
                            short op2)

multiplySlow

private static long multiplySlow(long op1,
                                 short op2)

multiply

public static long multiply(long op1,
                            int op2)

multiplySlow

private static long multiplySlow(long op1,
                                 int op2)

multiply

public static long multiply(long op1,
                            long op2)

multiplySlow

private static long multiplySlow(long op1,
                                 long op2)

multiply

public static double multiply(long op1,
                              float op2)

multiplySlow

private static double multiplySlow(long op1,
                                   float op2)

multiply

public static double multiply(long op1,
                              double op2)

multiplySlow

private static double multiplySlow(long op1,
                                   double op2)

multiply

public static double multiply(float op1,
                              byte op2)

multiplySlow

private static double multiplySlow(float op1,
                                   byte op2)

multiply

public static double multiply(float op1,
                              short op2)

multiplySlow

private static double multiplySlow(float op1,
                                   short op2)

multiply

public static double multiply(float op1,
                              int op2)

multiplySlow

private static double multiplySlow(float op1,
                                   int op2)

multiply

public static double multiply(float op1,
                              long op2)

multiplySlow

private static double multiplySlow(float op1,
                                   long op2)

multiply

public static double multiply(float op1,
                              float op2)

multiplySlow

private static double multiplySlow(float op1,
                                   float op2)

multiply

public static double multiply(float op1,
                              double op2)

multiplySlow

private static double multiplySlow(float op1,
                                   double op2)

multiply

public static double multiply(double op1,
                              byte op2)

multiplySlow

private static double multiplySlow(double op1,
                                   byte op2)

multiply

public static double multiply(double op1,
                              short op2)

multiplySlow

private static double multiplySlow(double op1,
                                   short op2)

multiply

public static double multiply(double op1,
                              int op2)

multiplySlow

private static double multiplySlow(double op1,
                                   int op2)

multiply

public static double multiply(double op1,
                              long op2)

multiplySlow

private static double multiplySlow(double op1,
                                   long op2)

multiply

public static double multiply(double op1,
                              float op2)

multiplySlow

private static double multiplySlow(double op1,
                                   float op2)

multiply

public static double multiply(double op1,
                              double op2)

multiplySlow

private static double multiplySlow(double op1,
                                   double op2)

div

public static int div(byte op1,
                      byte op2)

divSlow

private static int divSlow(byte op1,
                           byte op2)

div

public static int div(byte op1,
                      short op2)

divSlow

private static int divSlow(byte op1,
                           short op2)

div

public static int div(byte op1,
                      int op2)

divSlow

private static int divSlow(byte op1,
                           int op2)

div

public static long div(byte op1,
                       long op2)

divSlow

private static long divSlow(byte op1,
                            long op2)

div

public static double div(byte op1,
                         float op2)

divSlow

private static double divSlow(byte op1,
                              float op2)

div

public static double div(byte op1,
                         double op2)

divSlow

private static double divSlow(byte op1,
                              double op2)

div

public static int div(short op1,
                      byte op2)

divSlow

private static int divSlow(short op1,
                           byte op2)

div

public static int div(short op1,
                      short op2)

divSlow

private static int divSlow(short op1,
                           short op2)

div

public static int div(short op1,
                      int op2)

divSlow

private static int divSlow(short op1,
                           int op2)

div

public static long div(short op1,
                       long op2)

divSlow

private static long divSlow(short op1,
                            long op2)

div

public static double div(short op1,
                         float op2)

divSlow

private static double divSlow(short op1,
                              float op2)

div

public static double div(short op1,
                         double op2)

divSlow

private static double divSlow(short op1,
                              double op2)

div

public static int div(int op1,
                      byte op2)

divSlow

private static int divSlow(int op1,
                           byte op2)

div

public static int div(int op1,
                      short op2)

divSlow

private static int divSlow(int op1,
                           short op2)

div

public static int div(int op1,
                      int op2)

divSlow

private static int divSlow(int op1,
                           int op2)

div

public static long div(int op1,
                       long op2)

divSlow

private static long divSlow(int op1,
                            long op2)

div

public static double div(int op1,
                         float op2)

divSlow

private static double divSlow(int op1,
                              float op2)

div

public static double div(int op1,
                         double op2)

divSlow

private static double divSlow(int op1,
                              double op2)

div

public static long div(long op1,
                       byte op2)

divSlow

private static long divSlow(long op1,
                            byte op2)

div

public static long div(long op1,
                       short op2)

divSlow

private static long divSlow(long op1,
                            short op2)

div

public static long div(long op1,
                       int op2)

divSlow

private static long divSlow(long op1,
                            int op2)

div

public static long div(long op1,
                       long op2)

divSlow

private static long divSlow(long op1,
                            long op2)

div

public static double div(long op1,
                         float op2)

divSlow

private static double divSlow(long op1,
                              float op2)

div

public static double div(long op1,
                         double op2)

divSlow

private static double divSlow(long op1,
                              double op2)

div

public static double div(float op1,
                         byte op2)

divSlow

private static double divSlow(float op1,
                              byte op2)

div

public static double div(float op1,
                         short op2)

divSlow

private static double divSlow(float op1,
                              short op2)

div

public static double div(float op1,
                         int op2)

divSlow

private static double divSlow(float op1,
                              int op2)

div

public static double div(float op1,
                         long op2)

divSlow

private static double divSlow(float op1,
                              long op2)

div

public static double div(float op1,
                         float op2)

divSlow

private static double divSlow(float op1,
                              float op2)

div

public static double div(float op1,
                         double op2)

divSlow

private static double divSlow(float op1,
                              double op2)

div

public static double div(double op1,
                         byte op2)

divSlow

private static double divSlow(double op1,
                              byte op2)

div

public static double div(double op1,
                         short op2)

divSlow

private static double divSlow(double op1,
                              short op2)

div

public static double div(double op1,
                         int op2)

divSlow

private static double divSlow(double op1,
                              int op2)

div

public static double div(double op1,
                         long op2)

divSlow

private static double divSlow(double op1,
                              long op2)

div

public static double div(double op1,
                         float op2)

divSlow

private static double divSlow(double op1,
                              float op2)

div

public static double div(double op1,
                         double op2)

divSlow

private static double divSlow(double op1,
                              double op2)

or

public static int or(byte op1,
                     byte op2)

orSlow

private static int orSlow(byte op1,
                          byte op2)

or

public static int or(byte op1,
                     short op2)

orSlow

private static int orSlow(byte op1,
                          short op2)

or

public static int or(byte op1,
                     int op2)

orSlow

private static int orSlow(byte op1,
                          int op2)

or

public static long or(byte op1,
                      long op2)

orSlow

private static long orSlow(byte op1,
                           long op2)

or

public static int or(short op1,
                     byte op2)

orSlow

private static int orSlow(short op1,
                          byte op2)

or

public static int or(short op1,
                     short op2)

orSlow

private static int orSlow(short op1,
                          short op2)

or

public static int or(short op1,
                     int op2)

orSlow

private static int orSlow(short op1,
                          int op2)

or

public static long or(short op1,
                      long op2)

orSlow

private static long orSlow(short op1,
                           long op2)

or

public static int or(int op1,
                     byte op2)

orSlow

private static int orSlow(int op1,
                          byte op2)

or

public static int or(int op1,
                     short op2)

orSlow

private static int orSlow(int op1,
                          short op2)

or

public static int or(int op1,
                     int op2)

orSlow

private static int orSlow(int op1,
                          int op2)

or

public static long or(int op1,
                      long op2)

orSlow

private static long orSlow(int op1,
                           long op2)

or

public static long or(long op1,
                      byte op2)

orSlow

private static long orSlow(long op1,
                           byte op2)

or

public static long or(long op1,
                      short op2)

orSlow

private static long orSlow(long op1,
                           short op2)

or

public static long or(long op1,
                      int op2)

orSlow

private static long orSlow(long op1,
                           int op2)

or

public static long or(long op1,
                      long op2)

orSlow

private static long orSlow(long op1,
                           long op2)

and

public static int and(byte op1,
                      byte op2)

andSlow

private static int andSlow(byte op1,
                           byte op2)

and

public static int and(byte op1,
                      short op2)

andSlow

private static int andSlow(byte op1,
                           short op2)

and

public static int and(byte op1,
                      int op2)

andSlow

private static int andSlow(byte op1,
                           int op2)

and

public static long and(byte op1,
                       long op2)

andSlow

private static long andSlow(byte op1,
                            long op2)

and

public static int and(short op1,
                      byte op2)

andSlow

private static int andSlow(short op1,
                           byte op2)

and

public static int and(short op1,
                      short op2)

andSlow

private static int andSlow(short op1,
                           short op2)

and

public static int and(short op1,
                      int op2)

andSlow

private static int andSlow(short op1,
                           int op2)

and

public static long and(short op1,
                       long op2)

andSlow

private static long andSlow(short op1,
                            long op2)

and

public static int and(int op1,
                      byte op2)

andSlow

private static int andSlow(int op1,
                           byte op2)

and

public static int and(int op1,
                      short op2)

andSlow

private static int andSlow(int op1,
                           short op2)

and

public static int and(int op1,
                      int op2)

andSlow

private static int andSlow(int op1,
                           int op2)

and

public static long and(int op1,
                       long op2)

andSlow

private static long andSlow(int op1,
                            long op2)

and

public static long and(long op1,
                       byte op2)

andSlow

private static long andSlow(long op1,
                            byte op2)

and

public static long and(long op1,
                       short op2)

andSlow

private static long andSlow(long op1,
                            short op2)

and

public static long and(long op1,
                       int op2)

andSlow

private static long andSlow(long op1,
                            int op2)

and

public static long and(long op1,
                       long op2)

andSlow

private static long andSlow(long op1,
                            long op2)

xor

public static int xor(byte op1,
                      byte op2)

xorSlow

private static int xorSlow(byte op1,
                           byte op2)

xor

public static int xor(byte op1,
                      short op2)

xorSlow

private static int xorSlow(byte op1,
                           short op2)

xor

public static int xor(byte op1,
                      int op2)

xorSlow

private static int xorSlow(byte op1,
                           int op2)

xor

public static long xor(byte op1,
                       long op2)

xorSlow

private static long xorSlow(byte op1,
                            long op2)

xor

public static int xor(short op1,
                      byte op2)

xorSlow

private static int xorSlow(short op1,
                           byte op2)

xor

public static int xor(short op1,
                      short op2)

xorSlow

private static int xorSlow(short op1,
                           short op2)

xor

public static int xor(short op1,
                      int op2)

xorSlow

private static int xorSlow(short op1,
                           int op2)

xor

public static long xor(short op1,
                       long op2)

xorSlow

private static long xorSlow(short op1,
                            long op2)

xor

public static int xor(int op1,
                      byte op2)

xorSlow

private static int xorSlow(int op1,
                           byte op2)

xor

public static int xor(int op1,
                      short op2)

xorSlow

private static int xorSlow(int op1,
                           short op2)

xor

public static int xor(int op1,
                      int op2)

xorSlow

private static int xorSlow(int op1,
                           int op2)

xor

public static long xor(int op1,
                       long op2)

xorSlow

private static long xorSlow(int op1,
                            long op2)

xor

public static long xor(long op1,
                       byte op2)

xorSlow

private static long xorSlow(long op1,
                            byte op2)

xor

public static long xor(long op1,
                       short op2)

xorSlow

private static long xorSlow(long op1,
                            short op2)

xor

public static long xor(long op1,
                       int op2)

xorSlow

private static long xorSlow(long op1,
                            int op2)

xor

public static long xor(long op1,
                       long op2)

xorSlow

private static long xorSlow(long op1,
                            long op2)

intdiv

public static int intdiv(byte op1,
                         byte op2)

intdivSlow

private static int intdivSlow(byte op1,
                              byte op2)

intdiv

public static int intdiv(byte op1,
                         short op2)

intdivSlow

private static int intdivSlow(byte op1,
                              short op2)

intdiv

public static int intdiv(byte op1,
                         int op2)

intdivSlow

private static int intdivSlow(byte op1,
                              int op2)

intdiv

public static long intdiv(byte op1,
                          long op2)

intdivSlow

private static long intdivSlow(byte op1,
                               long op2)

intdiv

public static int intdiv(short op1,
                         byte op2)

intdivSlow

private static int intdivSlow(short op1,
                              byte op2)

intdiv

public static int intdiv(short op1,
                         short op2)

intdivSlow

private static int intdivSlow(short op1,
                              short op2)

intdiv

public static int intdiv(short op1,
                         int op2)

intdivSlow

private static int intdivSlow(short op1,
                              int op2)

intdiv

public static long intdiv(short op1,
                          long op2)

intdivSlow

private static long intdivSlow(short op1,
                               long op2)

intdiv

public static int intdiv(int op1,
                         byte op2)

intdivSlow

private static int intdivSlow(int op1,
                              byte op2)

intdiv

public static int intdiv(int op1,
                         short op2)

intdivSlow

private static int intdivSlow(int op1,
                              short op2)

intdiv

public static int intdiv(int op1,
                         int op2)

intdivSlow

private static int intdivSlow(int op1,
                              int op2)

intdiv

public static long intdiv(int op1,
                          long op2)

intdivSlow

private static long intdivSlow(int op1,
                               long op2)

intdiv

public static long intdiv(long op1,
                          byte op2)

intdivSlow

private static long intdivSlow(long op1,
                               byte op2)

intdiv

public static long intdiv(long op1,
                          short op2)

intdivSlow

private static long intdivSlow(long op1,
                               short op2)

intdiv

public static long intdiv(long op1,
                          int op2)

intdivSlow

private static long intdivSlow(long op1,
                               int op2)

intdiv

public static long intdiv(long op1,
                          long op2)

intdivSlow

private static long intdivSlow(long op1,
                               long op2)

mod

public static int mod(byte op1,
                      byte op2)

modSlow

private static int modSlow(byte op1,
                           byte op2)

mod

public static int mod(byte op1,
                      short op2)

modSlow

private static int modSlow(byte op1,
                           short op2)

mod

public static int mod(byte op1,
                      int op2)

modSlow

private static int modSlow(byte op1,
                           int op2)

mod

public static long mod(byte op1,
                       long op2)

modSlow

private static long modSlow(byte op1,
                            long op2)

mod

public static int mod(short op1,
                      byte op2)

modSlow

private static int modSlow(short op1,
                           byte op2)

mod

public static int mod(short op1,
                      short op2)

modSlow

private static int modSlow(short op1,
                           short op2)

mod

public static int mod(short op1,
                      int op2)

modSlow

private static int modSlow(short op1,
                           int op2)

mod

public static long mod(short op1,
                       long op2)

modSlow

private static long modSlow(short op1,
                            long op2)

mod

public static int mod(int op1,
                      byte op2)

modSlow

private static int modSlow(int op1,
                           byte op2)

mod

public static int mod(int op1,
                      short op2)

modSlow

private static int modSlow(int op1,
                           short op2)

mod

public static int mod(int op1,
                      int op2)

modSlow

private static int modSlow(int op1,
                           int op2)

mod

public static long mod(int op1,
                       long op2)

modSlow

private static long modSlow(int op1,
                            long op2)

mod

public static long mod(long op1,
                       byte op2)

modSlow

private static long modSlow(long op1,
                            byte op2)

mod

public static long mod(long op1,
                       short op2)

modSlow

private static long modSlow(long op1,
                            short op2)

mod

public static long mod(long op1,
                       int op2)

modSlow

private static long modSlow(long op1,
                            int op2)

mod

public static long mod(long op1,
                       long op2)

modSlow

private static long modSlow(long op1,
                            long op2)

leftShift

public static int leftShift(byte op1,
                            byte op2)

leftShiftSlow

private static int leftShiftSlow(byte op1,
                                 byte op2)

leftShift

public static int leftShift(byte op1,
                            short op2)

leftShiftSlow

private static int leftShiftSlow(byte op1,
                                 short op2)

leftShift

public static int leftShift(byte op1,
                            int op2)

leftShiftSlow

private static int leftShiftSlow(byte op1,
                                 int op2)

leftShift

public static long leftShift(byte op1,
                             long op2)

leftShiftSlow

private static long leftShiftSlow(byte op1,
                                  long op2)

leftShift

public static int leftShift(short op1,
                            byte op2)

leftShiftSlow

private static int leftShiftSlow(short op1,
                                 byte op2)

leftShift

public static int leftShift(short op1,
                            short op2)

leftShiftSlow

private static int leftShiftSlow(short op1,
                                 short op2)

leftShift

public static int leftShift(short op1,
                            int op2)

leftShiftSlow

private static int leftShiftSlow(short op1,
                                 int op2)

leftShift

public static long leftShift(short op1,
                             long op2)

leftShiftSlow

private static long leftShiftSlow(short op1,
                                  long op2)

leftShift

public static int leftShift(int op1,
                            byte op2)

leftShiftSlow

private static int leftShiftSlow(int op1,
                                 byte op2)

leftShift

public static int leftShift(int op1,
                            short op2)

leftShiftSlow

private static int leftShiftSlow(int op1,
                                 short op2)

leftShift

public static int leftShift(int op1,
                            int op2)

leftShiftSlow

private static int leftShiftSlow(int op1,
                                 int op2)

leftShift

public static long leftShift(int op1,
                             long op2)

leftShiftSlow

private static long leftShiftSlow(int op1,
                                  long op2)

leftShift

public static long leftShift(long op1,
                             byte op2)

leftShiftSlow

private static long leftShiftSlow(long op1,
                                  byte op2)

leftShift

public static long leftShift(long op1,
                             short op2)

leftShiftSlow

private static long leftShiftSlow(long op1,
                                  short op2)

leftShift

public static long leftShift(long op1,
                             int op2)

leftShiftSlow

private static long leftShiftSlow(long op1,
                                  int op2)

leftShift

public static long leftShift(long op1,
                             long op2)

leftShiftSlow

private static long leftShiftSlow(long op1,
                                  long op2)

rightShift

public static int rightShift(byte op1,
                             byte op2)

rightShiftSlow

private static int rightShiftSlow(byte op1,
                                  byte op2)

rightShift

public static int rightShift(byte op1,
                             short op2)

rightShiftSlow

private static int rightShiftSlow(byte op1,
                                  short op2)

rightShift

public static int rightShift(byte op1,
                             int op2)

rightShiftSlow

private static int rightShiftSlow(byte op1,
                                  int op2)

rightShift

public static long rightShift(byte op1,
                              long op2)

rightShiftSlow

private static long rightShiftSlow(byte op1,
                                   long op2)

rightShift

public static int rightShift(short op1,
                             byte op2)

rightShiftSlow

private static int rightShiftSlow(short op1,
                                  byte op2)

rightShift

public static int rightShift(short op1,
                             short op2)

rightShiftSlow

private static int rightShiftSlow(short op1,
                                  short op2)

rightShift

public static int rightShift(short op1,
                             int op2)

rightShiftSlow

private static int rightShiftSlow(short op1,
                                  int op2)

rightShift

public static long rightShift(short op1,
                              long op2)

rightShiftSlow

private static long rightShiftSlow(short op1,
                                   long op2)

rightShift

public static int rightShift(int op1,
                             byte op2)

rightShiftSlow

private static int rightShiftSlow(int op1,
                                  byte op2)

rightShift

public static int rightShift(int op1,
                             short op2)

rightShiftSlow

private static int rightShiftSlow(int op1,
                                  short op2)

rightShift

public static int rightShift(int op1,
                             int op2)

rightShiftSlow

private static int rightShiftSlow(int op1,
                                  int op2)

rightShift

public static long rightShift(int op1,
                              long op2)

rightShiftSlow

private static long rightShiftSlow(int op1,
                                   long op2)

rightShift

public static long rightShift(long op1,
                              byte op2)

rightShiftSlow

private static long rightShiftSlow(long op1,
                                   byte op2)

rightShift

public static long rightShift(long op1,
                              short op2)

rightShiftSlow

private static long rightShiftSlow(long op1,
                                   short op2)

rightShift

public static long rightShift(long op1,
                              int op2)

rightShiftSlow

private static long rightShiftSlow(long op1,
                                   int op2)

rightShift

public static long rightShift(long op1,
                              long op2)

rightShiftSlow

private static long rightShiftSlow(long op1,
                                   long op2)

rightShiftUnsigned

public static int rightShiftUnsigned(byte op1,
                                     byte op2)

rightShiftUnsignedSlow

private static int rightShiftUnsignedSlow(byte op1,
                                          byte op2)

rightShiftUnsigned

public static int rightShiftUnsigned(byte op1,
                                     short op2)

rightShiftUnsignedSlow

private static int rightShiftUnsignedSlow(byte op1,
                                          short op2)

rightShiftUnsigned

public static int rightShiftUnsigned(byte op1,
                                     int op2)

rightShiftUnsignedSlow

private static int rightShiftUnsignedSlow(byte op1,
                                          int op2)

rightShiftUnsigned

public static long rightShiftUnsigned(byte op1,
                                      long op2)

rightShiftUnsignedSlow

private static long rightShiftUnsignedSlow(byte op1,
                                           long op2)

rightShiftUnsigned

public static int rightShiftUnsigned(short op1,
                                     byte op2)

rightShiftUnsignedSlow

private static int rightShiftUnsignedSlow(short op1,
                                          byte op2)

rightShiftUnsigned

public static int rightShiftUnsigned(short op1,
                                     short op2)

rightShiftUnsignedSlow

private static int rightShiftUnsignedSlow(short op1,
                                          short op2)

rightShiftUnsigned

public static int rightShiftUnsigned(short op1,
                                     int op2)

rightShiftUnsignedSlow

private static int rightShiftUnsignedSlow(short op1,
                                          int op2)

rightShiftUnsigned

public static long rightShiftUnsigned(short op1,
                                      long op2)

rightShiftUnsignedSlow

private static long rightShiftUnsignedSlow(short op1,
                                           long op2)

rightShiftUnsigned

public static int rightShiftUnsigned(int op1,
                                     byte op2)

rightShiftUnsignedSlow

private static int rightShiftUnsignedSlow(int op1,
                                          byte op2)

rightShiftUnsigned

public static int rightShiftUnsigned(int op1,
                                     short op2)

rightShiftUnsignedSlow

private static int rightShiftUnsignedSlow(int op1,
                                          short op2)

rightShiftUnsigned

public static int rightShiftUnsigned(int op1,
                                     int op2)

rightShiftUnsignedSlow

private static int rightShiftUnsignedSlow(int op1,
                                          int op2)

rightShiftUnsigned

public static long rightShiftUnsigned(int op1,
                                      long op2)

rightShiftUnsignedSlow

private static long rightShiftUnsignedSlow(int op1,
                                           long op2)

rightShiftUnsigned

public static long rightShiftUnsigned(long op1,
                                      byte op2)

rightShiftUnsignedSlow

private static long rightShiftUnsignedSlow(long op1,
                                           byte op2)

rightShiftUnsigned

public static long rightShiftUnsigned(long op1,
                                      short op2)

rightShiftUnsignedSlow

private static long rightShiftUnsignedSlow(long op1,
                                           short op2)

rightShiftUnsigned

public static long rightShiftUnsigned(long op1,
                                      int op2)

rightShiftUnsignedSlow

private static long rightShiftUnsignedSlow(long op1,
                                           int op2)

rightShiftUnsigned

public static long rightShiftUnsigned(long op1,
                                      long op2)

rightShiftUnsignedSlow

private static long rightShiftUnsignedSlow(long op1,
                                           long op2)


Copyright © ${year} The Codehaus. All Rights Reserved.