ise.antelope.tasks
Class Math

java.lang.Object
  extended by ise.antelope.tasks.Math

public class Math
extends java.lang.Object

Provides access to java.lang.Math and java.lang.StrictMath for Ant. Provides add, subtract, multiply, divide and mod methods as well as access to all methods java.lang.Math and java.lang.StrictMath via reflection.

Copyright 2003, Dale Anson, all rights reserved


Nested Class Summary
 class Math.Candidate
           
 
Field Summary
static java.lang.Class BIGDECIMAL_TYPE
           
static java.lang.Class BIGINT_TYPE
           
 
Constructor Summary
Math()
           
Math(boolean strict)
           
 
Method Summary
static java.math.BigDecimal add(java.math.BigDecimal a, java.math.BigDecimal b)
           
static java.math.BigInteger add(java.math.BigInteger[] a)
           
static java.math.BigInteger add(java.math.BigInteger a, java.math.BigInteger b)
           
static double add(double[] a)
           
static double add(double a, double b)
           
static float add(float[] a)
           
static float add(float a, float b)
           
static int add(int[] a)
           
static int add(int a, int b)
           
static long add(long[] a)
           
static long add(long a, long b)
           
static java.math.BigInteger and(java.math.BigInteger a, java.math.BigInteger b)
           
static int and(int a, int b)
           
 java.lang.Number calculate(java.lang.String op, java.lang.String[] operands)
          Do a mathematical calculation.
 java.lang.Number calculate(java.lang.String op, java.lang.String type, java.lang.String[] operands)
          Do a mathematical calculation.
static java.math.BigDecimal divide(java.math.BigDecimal[] a)
           
static java.math.BigDecimal divide(java.math.BigDecimal a, java.math.BigDecimal b)
           
static java.math.BigInteger divide(java.math.BigInteger[] a)
           
static java.math.BigInteger divide(java.math.BigInteger a, java.math.BigInteger b)
           
static double divide(double[] a)
           
static double divide(double a, double b)
           
static float divide(float[] a)
           
static float divide(float a, float b)
           
static int divide(int[] a)
           
static int divide(int a, int b)
           
static long divide(long[] a)
           
static long divide(long a, long b)
           
static boolean equal(java.math.BigDecimal x, java.math.BigDecimal y)
           
static boolean equal(java.math.BigInteger x, java.math.BigInteger y)
           
static boolean equal(double x, double y)
           
static boolean equal(int x, int y)
           
static boolean equal(long x, long y)
           
static java.math.BigInteger factorial(java.math.BigInteger x)
           
static int factorial(double x)
           
static int factorial(float x)
           
static int factorial(int x)
           
static boolean greaterThan(java.math.BigDecimal x, java.math.BigDecimal y)
           
static boolean greaterThan(java.math.BigInteger x, java.math.BigInteger y)
           
static boolean greaterThan(double x, double y)
           
static boolean greaterThan(int x, int y)
           
static boolean greaterThan(long x, long y)
           
 boolean isStrict()
           
static boolean lessThan(java.math.BigDecimal x, java.math.BigDecimal y)
           
static boolean lessThan(java.math.BigInteger x, java.math.BigInteger y)
           
static boolean lessThan(double x, double y)
           
static boolean lessThan(int x, int y)
           
static boolean lessThan(long x, long y)
           
static java.math.BigDecimal max(java.math.BigDecimal a, java.math.BigDecimal b)
           
static java.math.BigInteger max(java.math.BigInteger a, java.math.BigInteger b)
           
static java.math.BigDecimal min(java.math.BigDecimal a, java.math.BigDecimal b)
           
static java.math.BigInteger min(java.math.BigInteger a, java.math.BigInteger b)
           
static java.math.BigInteger mod(java.math.BigInteger[] a)
           
static java.math.BigInteger mod(java.math.BigInteger a, java.math.BigInteger b)
           
static double mod(double[] a)
           
static double mod(double a, double b)
           
static float mod(float[] a)
           
static float mod(float a, float b)
           
static int mod(int[] a)
           
static int mod(int a, int b)
           
static long mod(long[] a)
           
static long mod(long a, long b)
           
static java.math.BigDecimal multiply(java.math.BigDecimal[] a)
           
static java.math.BigDecimal multiply(java.math.BigDecimal a, java.math.BigDecimal b)
           
static java.math.BigInteger multiply(java.math.BigInteger[] a)
           
static java.math.BigInteger multiply(java.math.BigInteger a, java.math.BigInteger b)
           
static double multiply(double[] a)
           
static double multiply(double a, double b)
           
static float multiply(float[] a)
           
static float multiply(float a, float b)
           
static int multiply(int[] a)
           
static int multiply(int a, int b)
           
static long multiply(long[] a)
           
static long multiply(long a, long b)
           
static java.math.BigInteger not(java.math.BigInteger a)
           
static int not(int a)
           
static boolean notEqual(java.math.BigDecimal x, java.math.BigDecimal y)
           
static boolean notEqual(java.math.BigInteger x, java.math.BigInteger y)
           
static boolean notEqual(double x, double y)
           
static boolean notEqual(int x, int y)
           
static boolean notEqual(long x, long y)
           
static java.math.BigInteger or(java.math.BigInteger a, java.math.BigInteger b)
           
static int or(int a, int b)
           
static java.math.BigDecimal pow(java.math.BigDecimal y, java.math.BigDecimal x)
          y raised to the x power
static java.math.BigInteger pow(java.math.BigInteger y, java.math.BigInteger x)
          y raised to the x power
 void setStrict(boolean strict)
           
static java.math.BigDecimal subtract(java.math.BigDecimal[] a)
           
static java.math.BigDecimal subtract(java.math.BigDecimal a, java.math.BigDecimal b)
           
static java.math.BigInteger subtract(java.math.BigInteger[] a)
           
static java.math.BigInteger subtract(java.math.BigInteger a, java.math.BigInteger b)
           
static double subtract(double[] a)
           
static double subtract(double a, double b)
           
static float subtract(float[] a)
           
static float subtract(float a, float b)
           
static int subtract(int[] a)
           
static int subtract(int a, int b)
           
static long subtract(long[] a)
           
static long subtract(long a, long b)
           
static java.math.BigInteger xor(java.math.BigInteger a, java.math.BigInteger b)
           
static int xor(int a, int b)
           
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

BIGDECIMAL_TYPE

public static java.lang.Class BIGDECIMAL_TYPE

BIGINT_TYPE

public static java.lang.Class BIGINT_TYPE
Constructor Detail

Math

public Math()

Math

public Math(boolean strict)
Method Detail

setStrict

public void setStrict(boolean strict)

isStrict

public boolean isStrict()

add

public static java.math.BigDecimal add(java.math.BigDecimal a,
                                       java.math.BigDecimal b)

add

public static java.math.BigInteger add(java.math.BigInteger a,
                                       java.math.BigInteger b)

and

public static java.math.BigInteger and(java.math.BigInteger a,
                                       java.math.BigInteger b)

and

public static int and(int a,
                      int b)

or

public static java.math.BigInteger or(java.math.BigInteger a,
                                      java.math.BigInteger b)

or

public static int or(int a,
                     int b)

not

public static java.math.BigInteger not(java.math.BigInteger a)

not

public static int not(int a)

xor

public static java.math.BigInteger xor(java.math.BigInteger a,
                                       java.math.BigInteger b)

xor

public static int xor(int a,
                      int b)

add

public static double add(double a,
                         double b)

add

public static float add(float a,
                        float b)

add

public static long add(long a,
                       long b)

add

public static int add(int a,
                      int b)

add

public static java.math.BigInteger add(java.math.BigInteger[] a)

add

public static double add(double[] a)

add

public static float add(float[] a)

add

public static long add(long[] a)

add

public static int add(int[] a)

subtract

public static java.math.BigDecimal subtract(java.math.BigDecimal a,
                                            java.math.BigDecimal b)

subtract

public static java.math.BigInteger subtract(java.math.BigInteger a,
                                            java.math.BigInteger b)

subtract

public static double subtract(double a,
                              double b)

subtract

public static float subtract(float a,
                             float b)

subtract

public static long subtract(long a,
                            long b)

subtract

public static int subtract(int a,
                           int b)

subtract

public static java.math.BigDecimal subtract(java.math.BigDecimal[] a)

subtract

public static java.math.BigInteger subtract(java.math.BigInteger[] a)

subtract

public static double subtract(double[] a)

subtract

public static float subtract(float[] a)

subtract

public static long subtract(long[] a)

subtract

public static int subtract(int[] a)

multiply

public static java.math.BigDecimal multiply(java.math.BigDecimal a,
                                            java.math.BigDecimal b)

multiply

public static java.math.BigInteger multiply(java.math.BigInteger a,
                                            java.math.BigInteger b)

multiply

public static double multiply(double a,
                              double b)

multiply

public static float multiply(float a,
                             float b)

multiply

public static long multiply(long a,
                            long b)

multiply

public static int multiply(int a,
                           int b)

multiply

public static java.math.BigDecimal multiply(java.math.BigDecimal[] a)

multiply

public static java.math.BigInteger multiply(java.math.BigInteger[] a)

multiply

public static double multiply(double[] a)

multiply

public static float multiply(float[] a)

multiply

public static long multiply(long[] a)

multiply

public static int multiply(int[] a)

divide

public static java.math.BigDecimal divide(java.math.BigDecimal a,
                                          java.math.BigDecimal b)

divide

public static java.math.BigInteger divide(java.math.BigInteger a,
                                          java.math.BigInteger b)

divide

public static double divide(double a,
                            double b)

divide

public static float divide(float a,
                           float b)

divide

public static long divide(long a,
                          long b)

divide

public static int divide(int a,
                         int b)

divide

public static java.math.BigDecimal divide(java.math.BigDecimal[] a)

divide

public static java.math.BigInteger divide(java.math.BigInteger[] a)

divide

public static double divide(double[] a)

divide

public static float divide(float[] a)

divide

public static long divide(long[] a)

divide

public static int divide(int[] a)

mod

public static java.math.BigInteger mod(java.math.BigInteger a,
                                       java.math.BigInteger b)

mod

public static double mod(double a,
                         double b)

mod

public static float mod(float a,
                        float b)

mod

public static long mod(long a,
                       long b)

mod

public static int mod(int a,
                      int b)

mod

public static java.math.BigInteger mod(java.math.BigInteger[] a)

mod

public static double mod(double[] a)

mod

public static float mod(float[] a)

mod

public static long mod(long[] a)

mod

public static int mod(int[] a)

greaterThan

public static boolean greaterThan(int x,
                                  int y)

greaterThan

public static boolean greaterThan(long x,
                                  long y)

greaterThan

public static boolean greaterThan(double x,
                                  double y)

greaterThan

public static boolean greaterThan(java.math.BigInteger x,
                                  java.math.BigInteger y)

greaterThan

public static boolean greaterThan(java.math.BigDecimal x,
                                  java.math.BigDecimal y)

lessThan

public static boolean lessThan(int x,
                               int y)

lessThan

public static boolean lessThan(long x,
                               long y)

lessThan

public static boolean lessThan(double x,
                               double y)

lessThan

public static boolean lessThan(java.math.BigInteger x,
                               java.math.BigInteger y)

lessThan

public static boolean lessThan(java.math.BigDecimal x,
                               java.math.BigDecimal y)

equal

public static boolean equal(int x,
                            int y)

equal

public static boolean equal(long x,
                            long y)

equal

public static boolean equal(double x,
                            double y)

equal

public static boolean equal(java.math.BigInteger x,
                            java.math.BigInteger y)

equal

public static boolean equal(java.math.BigDecimal x,
                            java.math.BigDecimal y)

notEqual

public static boolean notEqual(int x,
                               int y)

notEqual

public static boolean notEqual(long x,
                               long y)

notEqual

public static boolean notEqual(double x,
                               double y)

notEqual

public static boolean notEqual(java.math.BigInteger x,
                               java.math.BigInteger y)

notEqual

public static boolean notEqual(java.math.BigDecimal x,
                               java.math.BigDecimal y)

factorial

public static java.math.BigInteger factorial(java.math.BigInteger x)

factorial

public static int factorial(double x)

factorial

public static int factorial(float x)

factorial

public static int factorial(int x)

min

public static java.math.BigDecimal min(java.math.BigDecimal a,
                                       java.math.BigDecimal b)

min

public static java.math.BigInteger min(java.math.BigInteger a,
                                       java.math.BigInteger b)

max

public static java.math.BigDecimal max(java.math.BigDecimal a,
                                       java.math.BigDecimal b)

max

public static java.math.BigInteger max(java.math.BigInteger a,
                                       java.math.BigInteger b)

pow

public static java.math.BigInteger pow(java.math.BigInteger y,
                                       java.math.BigInteger x)
y raised to the x power


pow

public static java.math.BigDecimal pow(java.math.BigDecimal y,
                                       java.math.BigDecimal x)
y raised to the x power


calculate

public java.lang.Number calculate(java.lang.String op,
                                  java.lang.String[] operands)
Do a mathematical calculation. The allowed operations are all operations supported by java.lang.Math and this class. Assumes data type is "double".

Parameters:
op - the name of a mathematical operation to perform
operands - the operands for the operation, these strings must parse to numbers.

calculate

public java.lang.Number calculate(java.lang.String op,
                                  java.lang.String type,
                                  java.lang.String[] operands)
Do a mathematical calculation. The allowed operations are all operations supported by java.lang.Math.

Parameters:
op - the name of a mathematical operation to perform
type - the data type of the operands
operands - the operands for the operation
Returns:
the result of the calculation. For boolean operations, returns 1 for true, 0 for false;