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