java.lang.Object
- 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

Nested Classes
Modifier and Type Class Description

class Math.Candidate

Field Summary

Fields
Modifier and Type Field Description

static java.lang.Class BIGDECIMAL_TYPE

static java.lang.Class BIGINT_TYPE

Constructor Summary

Constructors
Constructor Description

Math()

Math(boolean strict)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`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.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 int`	`and(int a, int b)`
`static java.math.BigInteger`	`and(java.math.BigInteger a, java.math.BigInteger 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 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 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 boolean`	`equal(double x, double y)`
`static boolean`	`equal(int x, int y)`
`static boolean`	`equal(long x, long y)`
`static boolean`	`equal(java.math.BigDecimal x, java.math.BigDecimal y)`
`static boolean`	`equal(java.math.BigInteger x, java.math.BigInteger y)`
`static int`	`factorial(double x)`
`static int`	`factorial(float x)`
`static int`	`factorial(int x)`
`static java.math.BigInteger`	`factorial(java.math.BigInteger x)`
`static boolean`	`greaterThan(double x, double y)`
`static boolean`	`greaterThan(int x, int y)`
`static boolean`	`greaterThan(long x, long y)`
`static boolean`	`greaterThan(java.math.BigDecimal x, java.math.BigDecimal y)`
`static boolean`	`greaterThan(java.math.BigInteger x, java.math.BigInteger y)`
`boolean`	`isStrict()`
`static boolean`	`lessThan(double x, double y)`
`static boolean`	`lessThan(int x, int y)`
`static boolean`	`lessThan(long x, long y)`
`static boolean`	`lessThan(java.math.BigDecimal x, java.math.BigDecimal y)`
`static boolean`	`lessThan(java.math.BigInteger x, java.math.BigInteger 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 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.BigInteger`	`mod(java.math.BigInteger[] a)`
`static java.math.BigInteger`	`mod(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.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 int`	`not(int a)`
`static java.math.BigInteger`	`not(java.math.BigInteger a)`
`static boolean`	`notEqual(double x, double y)`
`static boolean`	`notEqual(int x, int y)`
`static boolean`	`notEqual(long x, long y)`
`static boolean`	`notEqual(java.math.BigDecimal x, java.math.BigDecimal y)`
`static boolean`	`notEqual(java.math.BigInteger x, java.math.BigInteger y)`
`static int`	`or(int a, int b)`
`static java.math.BigInteger`	`or(java.math.BigInteger a, java.math.BigInteger 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 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.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 int`	`xor(int a, int b)`
`static java.math.BigInteger`	`xor(java.math.BigInteger a, java.math.BigInteger 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;

Modifier and Type	Field	Description
`static java.lang.Class`	`BIGDECIMAL_TYPE`
`static java.lang.Class`	`BIGINT_TYPE`

Class Math

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

BIGDECIMAL_TYPE

BIGINT_TYPE

Constructor Detail

Math

Math

Method Detail

setStrict

isStrict

add

add

and

and

or

or

not

not

xor

xor

add

add

add

add

add

add

add

add

add

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

mod

mod

mod

mod

mod

mod

mod

mod

mod

mod