Fmath

Documentation of 'flanagan.math.Fmath' Java class Fmath

All Classes

Summary:
Nested |
Field |
Constr |
Method

Detail:
Field |
Constr |
Method

java.lang.Object
- flanagan.math.Fmath

public class Fmath
extends java.lang.Object

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`C_LIGHT`
`static double`	`E`
`static double`	`EPSILON_0`
`static double`	`ETA_0`
`static double`	`EULER_CONSTANT_GAMMA`
`static double`	`F_FARADAY`
`static double`	`H_PLANCK`
`static double`	`H_PLANCK_RED`
`static double`	`K_BOLTZMANN`
`static double`	`M_ELECTRON`
`static double`	`M_NEUTRON`
`static double`	`M_PROTON`
`static double`	`MU_0`
`static double`	`N_AVAGADRO`
`static double`	`PI`
`static double`	`Q_ELECTRON`
`static double`	`R_GAS`
`static double`	`T_ABS`

Constructor Summary

Constructors
Constructor and Description

Fmath()

Constructors
Constructor and Description
`Fmath()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`acos(double a)`
`static double`	`acosh(double a)`
`static double`	`acot(double a)`
`static double`	`acot2(double a, double b)`
`static double`	`acoth(double a)`
`static double`	`acovers(double a)`
`static double`	`acsc(double a)`
`static double`	`acsch(double a)`
`static double`	`aexsec(double a)`
`static double`	`ahav(double a)`
`static double`	`angle(double sideAC, double sideBC, double sideAB)`
`static double`	`angle(double xAtA, double yAtA, double xAtB, double yAtB, double xAtC, double yAtC)`
`static double`	`antilog(double x)`
`static float`	`antilog(float x)`
`static double`	`antilog10(double x)`
`static float`	`antilog10(float x)`
`static double`	`antilog2(double x)`
`static float`	`antilog2(float x)`
`static double[]`	`arrayAbs(double[] aa)`
`static float[]`	`arrayAbs(float[] aa)`
`static int[]`	`arrayAbs(int[] aa)`
`static long[]`	`arrayAbs(long[] aa)`
`static double[]`	`arrayMultByConstant(double[] aa, double constant)`
`static double[]`	`arrayMultByConstant(double[] aa, int constant)`
`static double[]`	`arrayMultByConstant(int[] aa, double constant)`
`static double[]`	`arrayMultByConstant(int[] aa, int constant)`
`static long`	`arrayPositiveElementsSum(long[] array)`
`static double`	`arrayProduct(double[] array)`
`static float`	`arrayProduct(float[] array)`
`static int`	`arrayProduct(int[] array)`
`static long`	`arrayProduct(long[] array)`
`static double`	`arraySum(double[] array)`
`static float`	`arraySum(float[] array)`
`static int`	`arraySum(int[] array)`
`static long`	`arraySum(long[] array)`
`static double`	`asec(double a)`
`static double`	`asech(double a)`
`static double`	`asin(double a)`
`static double`	`asinh(double a)`
`static double`	`atan(double a)`
`static double`	`atan2(double a, double b)`
`static double`	`atanh(double a)`
`static double`	`avers(double a)`
`static double[]`	`byteTOdouble(byte[] aa)`
`static float[]`	`byteTOfloat(byte[] aa)`
`static int[]`	`byteTOint(byte[] aa)`
`static long[]`	`byteTOlong(byte[] aa)`
`static short[]`	`byteTOshort(byte[] aa)`
`static double`	`calcBMIimperial(double height, double weight)`
`static double`	`calcBMImetric(double height, double weight)`
`static double`	`calcWeightFromBMIimperial(double bmi, double height)`
`static double`	`calcWeightFromBMImetric(double bmi, double height)`
`static double`	`calorieToJoule(double cal)`
`static double`	`celsiusToFahren(double cels)`
`static double`	`celsiusToKelvin(double cels)`
`static int`	`checkPrecision(double number)`
`static int`	`checkPrecision(float number)`
`static int`	`compare(byte x, byte y)`
`static boolean`	`compare(double[] array1, double[] array2)`
`static int`	`compare(double x, double y)`
`static boolean`	`compare(float[] array1, float[] array2)`
`static int`	`compare(float x, float y)`
`static boolean`	`compare(int[] array1, int[] array2)`
`static int`	`compare(int x, int y)`
`static boolean`	`compare(long[] array1, long[] array2)`
`static int`	`compare(long x, long y)`
`static int`	`compare(short x, short y)`
`static byte[]`	`concatenate(byte[] aa, byte[] bb)`
`static char[]`	`concatenate(char[] aa, char[] bb)`
`static double[]`	`concatenate(double[] aa, double[] bb)`
`static float[]`	`concatenate(float[] aa, float[] bb)`
`static int[]`	`concatenate(int[] aa, int[] bb)`
`static long[]`	`concatenate(long[] aa, long[] bb)`
`static java.lang.Object[]`	`concatenate(java.lang.Object[] aa, java.lang.Object[] bb)`
`static short[]`	`concatenate(short[] aa, short[] bb)`
`static java.lang.String[]`	`concatenate(java.lang.String[] aa, java.lang.String[] bb)`
`static boolean[]`	`copy(boolean[] array)`
`static boolean[][]`	`copy(boolean[][] array)`
`static boolean[][][]`	`copy(boolean[][][] array)`
`static boolean[][][][]`	`copy(boolean[][][][] array)`
`static char[]`	`copy(char[] array)`
`static char[][]`	`copy(char[][] array)`
`static char[][][]`	`copy(char[][][] array)`
`static char[][][][]`	`copy(char[][][][] array)`
`static double[]`	`copy(double[] array)`
`static double[][]`	`copy(double[][] array)`
`static double[][][]`	`copy(double[][][] array)`
`static double[][][][]`	`copy(double[][][][] array)`
`static float[]`	`copy(float[] array)`
`static float[][]`	`copy(float[][] array)`
`static float[][][]`	`copy(float[][][] array)`
`static float[][][][]`	`copy(float[][][][] array)`
`static int[]`	`copy(int[] array)`
`static int[][]`	`copy(int[][] array)`
`static int[][][]`	`copy(int[][][] array)`
`static int[][][][]`	`copy(int[][][][] array)`
`static long[]`	`copy(long[] array)`
`static long[][]`	`copy(long[][] array)`
`static long[][][]`	`copy(long[][][] array)`
`static long[][][][]`	`copy(long[][][][] array)`
`static java.lang.Object`	`copy(java.lang.Object obj)`
`static java.lang.String[]`	`copy(java.lang.String[] array)`
`static java.lang.String[][]`	`copy(java.lang.String[][] array)`
`static java.lang.String[][][]`	`copy(java.lang.String[][][] array)`
`static java.lang.String[][][][]`	`copy(java.lang.String[][][][] array)`
`static java.lang.Object`	`copyObject(java.lang.Object obj)`
`static double`	`cos(double arg)`
`static double`	`cos(double sideAC, double sideBC, double sideAB)`
`static double`	`cos(double xAtA, double yAtA, double xAtB, double yAtB, double xAtC, double yAtC)`
`static double`	`cosh(double a)`
`static double`	`cot(double a)`
`static double`	`coth(double a)`
`static double`	`covers(double a)`
`static double`	`csc(double a)`
`static double`	`csch(double a)`
`static double`	`cupUStoPintUK(double cupUS)`
`static long`	`dateToJavaMilliS(int year, int month, int day, int hour, int min, int sec)`
`static double`	`degToRad(double deg)`
`static int[]`	`doubleTOint(double[] aa)`
`static double`	`evToNm(double ev)`
`static double`	`exsec(double a)`
`static java.math.BigDecimal`	`factorial(java.math.BigDecimal n)`
`static java.math.BigInteger`	`factorial(java.math.BigInteger n)`
`static double`	`factorial(double n)`
`static int`	`factorial(int n)`
`static long`	`factorial(long n)`
`static double`	`fahrenToCelsius(double fahr)`
`static double[]`	`floatTOdouble(float[] aa)`
`static double`	`fluidOunceUKtoUS(double flOzUK)`
`static double`	`fluidOunceUStoUK(double flOzUS)`
`static double`	`footToMetre(double ft)`
`static double`	`frequencyToRadialFrequency(double frequency)`
`static double`	`gallonPerMileToLitrePerKm(double gallPmile)`
`static double`	`gallonToLitre(double gall)`
`static double`	`gallonUKtoUS(double gallonUK)`
`static double`	`gallonUStoUK(double gallonUS)`
`static double`	`gramToOunce(double gm)`
`static double`	`hav(double a)`
`static double`	`hypot(double aa, double bb)`
`static float`	`hypot(float aa, float bb)`
`static double`	`inchToMillimetre(double in)`
`static int`	`indexOf(byte[] array, byte value)`
`static int`	`indexOf(char[] array, char value)`
`static int`	`indexOf(double[] array, double value)`
`static int`	`indexOf(float[] array, float value)`
`static int`	`indexOf(int[] array, int value)`
`static int`	`indexOf(long[] array, long value)`
`static int`	`indexOf(java.lang.Object[] array, java.lang.Object value)`
`static int`	`indexOf(short[] array, short value)`
`static int`	`indexOf(java.lang.String[] array, java.lang.String value)`
`static int[]`	`indicesOf(byte[] array, byte value)`
`static int[]`	`indicesOf(char[] array, char value)`
`static int[]`	`indicesOf(double[] array, double value)`
`static int[]`	`indicesOf(float[] array, float value)`
`static int[]`	`indicesOf(int[] array, int value)`
`static int[]`	`indicesOf(long[] array, long value)`
`static int[]`	`indicesOf(java.lang.Object[] array, java.lang.Object value)`
`static int[]`	`indicesOf(short[] array, short value)`
`static int[]`	`indicesOf(java.lang.String[] array, java.lang.String value)`
`static double[]`	`intTOdouble(int[] aa)`
`static float[]`	`intTOfloat(int[] aa)`
`static long[]`	`intTOlong(int[] aa)`
`static double[]`	`invertElements(double[] aa)`
`static float[]`	`invertElements(float[] aa)`
`static boolean`	`isEqual(char x, char y)`
`static boolean`	`isEqual(double x, double y)`
`static boolean`	`isEqual(float x, float y)`
`static boolean`	`isEqual(int x, int y)`
`static boolean`	`isEqual(java.lang.String x, java.lang.String y)`
`static boolean`	`isEqualWithinLimits(java.math.BigDecimal x, java.math.BigDecimal y, java.math.BigDecimal limit)`
`static boolean`	`isEqualWithinLimits(java.math.BigInteger x, java.math.BigInteger y, java.math.BigInteger limit)`
`static boolean`	`isEqualWithinLimits(double x, double y, double limit)`
`static boolean`	`isEqualWithinLimits(float x, float y, float limit)`
`static boolean`	`isEqualWithinLimits(int x, int y, int limit)`
`static boolean`	`isEqualWithinLimits(long x, long y, long limit)`
`static boolean`	`isEqualWithinPerCent(java.math.BigDecimal x, java.math.BigDecimal y, java.math.BigDecimal perCent)`
`static boolean`	`isEqualWithinPerCent(java.math.BigInteger x, java.math.BigInteger y, java.math.BigDecimal perCent)`
`static boolean`	`isEqualWithinPerCent(java.math.BigInteger x, java.math.BigInteger y, java.math.BigInteger perCent)`
`static boolean`	`isEqualWithinPerCent(double x, double y, double perCent)`
`static boolean`	`isEqualWithinPerCent(float x, float y, float perCent)`
`static boolean`	`isEqualWithinPerCent(int x, int y, double perCent)`
`static boolean`	`isEqualWithinPerCent(int x, int y, int perCent)`
`static boolean`	`isEqualWithinPerCent(long x, long y, double perCent)`
`static boolean`	`isEqualWithinPerCent(long x, long y, long perCent)`
`static boolean`	`isEven(double x)`
`static boolean`	`isEven(float x)`
`static boolean`	`isEven(int x)`
`static boolean`	`isInfinity(double x)`
`static boolean`	`isInfinity(float x)`
`static boolean`	`isInteger(double x)`
`static boolean`	`isInteger(double[] x)`
`static boolean`	`isInteger(float x)`
`static boolean`	`isInteger(float[] x)`
`static boolean`	`isInteger(java.lang.Number numberAsObject)`
`static boolean`	`isInteger(java.lang.Number[] numberAsObject)`
`static boolean`	`isMinusInfinity(double x)`
`static boolean`	`isMinusInfinity(float x)`
`static boolean`	`isNaN(double x)`
`static boolean`	`isNaN(float x)`
`static boolean`	`isOdd(double x)`
`static boolean`	`isOdd(float x)`
`static boolean`	`isOdd(int x)`
`static boolean`	`isPlusInfinity(double x)`
`static boolean`	`isPlusInfinity(float x)`
`static double`	`jouleToCalorie(double joule)`
`static double`	`kelvinToCelsius(double kelv)`
`static double`	`kgToPound(double kg)`
`static double`	`kgToTon(double kg)`
`static double`	`kmPerLitreToMilePerGallon(double kmPlitre)`
`static double`	`kmToMile(double km)`
`static boolean`	`leapYear(int year)`
`static double`	`litrePerKmToGallonPerMile(double litrePkm)`
`static double`	`litreToGallon(double litre)`
`static double`	`litreToPint(double litre)`
`static double`	`litreToQuart(double litre)`
`static double[]`	`lnElements(double[] aa)`
`static float[]`	`lnElements(float[] aa)`
`static double`	`log(double a)`
`static float`	`log(float a)`
`static double`	`log10(double a)`
`static double`	`log10(double a, double b)`
`static double`	`log10(double a, int b)`
`static float`	`log10(float a)`
`static float`	`log10(float a, float b)`
`static float`	`log10(float a, int b)`
`static double[]`	`log10Elements(double[] aa)`
`static float[]`	`log10Elements(float[] aa)`
`static double`	`log2(double a)`
`static float`	`log2(float a)`
`static double`	`logFactorial(double n)`
`static double`	`logFactorial(int n)`
`static double`	`logFactorial(long n)`
`static double[]`	`longTOdouble(long[] aa)`
`static float[]`	`longTOfloat(long[] aa)`
`static double`	`maximum(double[] aa)`
`static float`	`maximum(float[] aa)`
`static int`	`maximum(int[] aa)`
`static long`	`maximum(long[] aa)`
`static double`	`maximumDifference(double[] aa)`
`static float`	`maximumDifference(float[] aa)`
`static int`	`maximumDifference(int[] aa)`
`static long`	`maximumDifference(long[] aa)`
`static double`	`metreToFoot(double metre)`
`static double`	`metreToYard(double metre)`
`static double`	`milePerGallonToKmPerLitre(double milePgall)`
`static double`	`mileToKm(double mile)`
`static double`	`millimetreToInch(double mm)`
`static double`	`minimum(double[] aa)`
`static float`	`minimum(float[] aa)`
`static int`	`minimum(int[] aa)`
`static long`	`minimum(long[] aa)`
`static double`	`minimumDifference(double[] aa)`
`static float`	`minimumDifference(float[] aa)`
`static int`	`minimumDifference(int[] aa)`
`static long`	`minimumDifference(long[] aa)`
`static double`	`molarToPercentWeightByVol(double molar, double molWeight)`
`static int`	`nearestElementIndex(double[] array, double value)`
`static int`	`nearestElementIndex(int[] array, int value)`
`static double`	`nearestElementValue(double[] array, double value)`
`static int`	`nearestElementValue(int[] array, int value)`
`static int`	`nearestHigherElementIndex(double[] array, double value)`
`static int`	`nearestHigherElementIndex(int[] array, int value)`
`static double`	`nearestHigherElementValue(double[] array, double value)`
`static int`	`nearestHigherElementValue(int[] array, int value)`
`static int`	`nearestLowerElementIndex(double[] array, double value)`
`static int`	`nearestLowerElementIndex(int[] array, int value)`
`static double`	`nearestLowerElementValue(double[] array, double value)`
`static int`	`nearestLowerElementValue(int[] array, int value)`
`static double`	`nmToEv(double nm)`
`static double`	`nsinc(double a)`
`static double`	`ounceToGram(double oz)`
`static double`	`percentWeightByVolToMolar(double perCent, double molWeight)`
`static double`	`pintToLitre(double pint)`
`static double`	`pintUKtoCupUS(double pintUK)`
`static double`	`pintUKtoUS(double pintUK)`
`static double`	`pintUStoUK(double pintUS)`
`static double`	`poundToKg(double pds)`
`static void`	`print(byte[] aa)`
`static void`	`print(char[] aa)`
`static void`	`print(double[] aa)`
`static void`	`print(double[][] aa)`
`static void`	`print(float[] aa)`
`static void`	`print(int[] aa)`
`static void`	`print(long[] aa)`
`static void`	`print(short[] aa)`
`static void`	`print(java.lang.String[] aa)`
`static void`	`println(byte[] aa)`
`static void`	`println(char[] aa)`
`static void`	`println(double[] aa)`
`static void`	`println(float[] aa)`
`static void`	`println(int[] aa)`
`static void`	`println(long[] aa)`
`static void`	`println(short[] aa)`
`static void`	`println(java.lang.String[] aa)`
`static double`	`quartToLitre(double quart)`
`static double`	`quartUKtoUS(double quartUK)`
`static double`	`quartUStoUK(double quartUS)`
`static double`	`radialFrequencyToFrequency(double radial)`
`static double`	`radToDeg(double rad)`
`static double[]`	`raiseElementsToPower(double[] aa, double power)`
`static double[]`	`raiseElementsToPower(double[] aa, int power)`
`static float[]`	`raiseElementsToPower(float[] aa, float power)`
`static float[]`	`raiseElementsToPower(float[] aa, int power)`
`static char[]`	`reverseArray(char[] aa)`
`static double[]`	`reverseArray(double[] aa)`
`static float[]`	`reverseArray(float[] aa)`
`static int[]`	`reverseArray(int[] aa)`
`static long[]`	`reverseArray(long[] aa)`
`static double`	`sec(double a)`
`static double`	`sech(double a)`
`static double[]`	`selectionSort(double[] aa)`
`static void`	`selectionSort(double[] aa, double[] bb, double[] cc, double[] dd)`
`static void`	`selectionSort(double[] aa, double[] bb, int[] indices)`
`static void`	`selectionSort(double[] aa, int[] bb, double[] cc, int[] dd)`
`static void`	`selectionSort(double[] aa, long[] bb, double[] cc, long[] dd)`
`static float[]`	`selectionSort(float[] aa)`
`static void`	`selectionSort(float[] aa, float[] bb, float[] cc, float[] dd)`
`static int[]`	`selectionSort(int[] aa)`
`static void`	`selectionSort(int[] aa, double[] bb, int[] cc, double[] dd)`
`static void`	`selectionSort(int[] aa, int[] bb, int[] cc, int[] dd)`
`static void`	`selectionSort(int[] aa, long[] bb, int[] cc, long[] dd)`
`static long[]`	`selectionSort(long[] aa)`
`static void`	`selectionSort(long[] aa, double[] bb, long[] cc, double[] dd)`
`static void`	`selectionSort(long[] aa, int[] bb, long[] cc, int[] dd)`
`static void`	`selectionSort(long[] aa, long[] bb, long[] cc, long[] dd)`
`static void`	`selectSort(double[] aa, double[] bb, int[] indices)`
`static java.util.ArrayList<java.lang.Object>`	`selectSortArrayList(double[] aa)`
`static java.util.Vector<java.lang.Object>`	`selectSortVector(double[] aa)`
`static double[]`	`shortTOdouble(short[] aa)`
`static float[]`	`shortTOfloat(short[] aa)`
`static int[]`	`shortTOint(short[] aa)`
`static long[]`	`shortTOlong(short[] aa)`
`static double`	`sign(double x)`
`static float`	`sign(float x)`
`static int`	`sign(int x)`
`static long`	`sign(long x)`
`static double`	`sin(double arg)`
`static double`	`sin(double sideAC, double sideBC, double sideAB)`
`static double`	`sin(double xAtA, double yAtA, double xAtB, double yAtB, double xAtC, double yAtC)`
`static double`	`sinc(double a)`
`static double`	`sinh(double a)`
`static java.math.BigDecimal`	`square(java.math.BigDecimal a)`
`static java.math.BigInteger`	`square(java.math.BigInteger a)`
`static double`	`square(double a)`
`static float`	`square(float a)`
`static int`	`square(int a)`
`static long`	`square(long a)`
`static double[]`	`squareRootElements(double[] aa)`
`static float[]`	`squareRootElements(float[] aa)`
`static double`	`tan(double arg)`
`static double`	`tan(double sideAC, double sideBC, double sideAB)`
`static double`	`tan(double xAtA, double yAtA, double xAtB, double yAtB, double xAtC, double yAtC)`
`static double`	`tanh(double a)`
`static double`	`tonToKg(double tons)`
`static double`	`truncate(double xDouble, int trunc)`
`static float`	`truncate(float xFloat, int trunc)`
`static double`	`vers(double a)`
`static double`	`yardToMetre(double yd)`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- N_AVAGADRO
```
public static final double N_AVAGADRO
```
  See Also:
  
  Constant Field Values
- K_BOLTZMANN
```
public static final double K_BOLTZMANN
```
  See Also:
  
  Constant Field Values
- H_PLANCK
```
public static final double H_PLANCK
```
  See Also:
  
  Constant Field Values
- H_PLANCK_RED
```
public static final double H_PLANCK_RED
```
  See Also:
  
  Constant Field Values
- C_LIGHT
```
public static final double C_LIGHT
```
  See Also:
  
  Constant Field Values
- R_GAS
```
public static final double R_GAS
```
  See Also:
  
  Constant Field Values
- F_FARADAY
```
public static final double F_FARADAY
```
  See Also:
  
  Constant Field Values
- T_ABS
```
public static final double T_ABS
```
  See Also:
  
  Constant Field Values
- Q_ELECTRON
```
public static final double Q_ELECTRON
```
  See Also:
  
  Constant Field Values
- M_ELECTRON
```
public static final double M_ELECTRON
```
  See Also:
  
  Constant Field Values
- M_PROTON
```
public static final double M_PROTON
```
  See Also:
  
  Constant Field Values
- M_NEUTRON
```
public static final double M_NEUTRON
```
  See Also:
  
  Constant Field Values
- EPSILON_0
```
public static final double EPSILON_0
```
  See Also:
  
  Constant Field Values
- MU_0
```
public static final double MU_0
```
  See Also:
  
  Constant Field Values
- ETA_0
```
public static final double ETA_0
```
  See Also:
  
  Constant Field Values
- EULER_CONSTANT_GAMMA
```
public static final double EULER_CONSTANT_GAMMA
```
  See Also:
  
  Constant Field Values
- PI
```
public static final double PI
```
  See Also:
  
  Constant Field Values
- E
```
public static final double E
```
  See Also:
  
  Constant Field Values

Constructor Detail
- Fmath
```
public Fmath()
```

Method Detail

log10
```
public static double log10(double a)
```

log10
```
public static float log10(float a)
```

antilog10

public static double antilog10(double x)

antilog10

public static float antilog10(float x)

log
```
public static double log(double a)
```

log
```
public static float log(float a)
```

antilog

public static double antilog(double x)

antilog
```
public static float antilog(float x)
```

log2
```
public static double log2(double a)
```

log2
```
public static float log2(float a)
```

antilog2

public static double antilog2(double x)

antilog2

public static float antilog2(float x)

log10

public static double log10(double a,
                           double b)

log10

public static double log10(double a,
                           int b)

log10

public static float log10(float a,
                          float b)

log10

public static float log10(float a,
                          int b)

square

public static double square(double a)

square
```
public static float square(float a)
```

square

public static java.math.BigDecimal square(java.math.BigDecimal a)

square
```
public static int square(int a)
```

square
```
public static long square(long a)
```

square

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

factorial
```
public static int factorial(int n)
```

factorial
```
public static long factorial(long n)
```

factorial

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

factorial

public static double factorial(double n)

factorial

public static java.math.BigDecimal factorial(java.math.BigDecimal n)

logFactorial

public static double logFactorial(int n)

logFactorial

public static double logFactorial(long n)

logFactorial

public static double logFactorial(double n)

sign
```
public static double sign(double x)
```

sign
```
public static float sign(float x)
```

sign
```
public static int sign(int x)
```

sign
```
public static long sign(long x)
```

hypot

public static double hypot(double aa,
                           double bb)

hypot

public static float hypot(float aa,
                          float bb)

angle

public static double angle(double xAtA,
                           double yAtA,
                           double xAtB,
                           double yAtB,
                           double xAtC,
                           double yAtC)

angle

public static double angle(double sideAC,
                           double sideBC,
                           double sideAB)

sin

public static double sin(double xAtA,
                         double yAtA,
                         double xAtB,
                         double yAtB,
                         double xAtC,
                         double yAtC)

sin

public static double sin(double sideAC,
                         double sideBC,
                         double sideAB)

sin
```
public static double sin(double arg)
```

asin
```
public static double asin(double a)
```

cos

public static double cos(double xAtA,
                         double yAtA,
                         double xAtB,
                         double yAtB,
                         double xAtC,
                         double yAtC)

cos

public static double cos(double sideAC,
                         double sideBC,
                         double sideAB)

cos
```
public static double cos(double arg)
```

acos
```
public static double acos(double a)
```

tan

public static double tan(double xAtA,
                         double yAtA,
                         double xAtB,
                         double yAtB,
                         double xAtC,
                         double yAtC)

tan

public static double tan(double sideAC,
                         double sideBC,
                         double sideAB)

tan
```
public static double tan(double arg)
```

atan
```
public static double atan(double a)
```

atan2

public static double atan2(double a,
                           double b)

cot
```
public static double cot(double a)
```

acot
```
public static double acot(double a)
```

acot2

public static double acot2(double a,
                           double b)

sec
```
public static double sec(double a)
```

asec
```
public static double asec(double a)
```

csc
```
public static double csc(double a)
```

acsc
```
public static double acsc(double a)
```

exsec
```
public static double exsec(double a)
```

aexsec

public static double aexsec(double a)

vers
```
public static double vers(double a)
```

avers
```
public static double avers(double a)
```

covers

public static double covers(double a)

acovers

public static double acovers(double a)

hav
```
public static double hav(double a)
```

ahav
```
public static double ahav(double a)
```

sinc
```
public static double sinc(double a)
```

nsinc
```
public static double nsinc(double a)
```

sinh
```
public static double sinh(double a)
```

asinh
```
public static double asinh(double a)
```

cosh
```
public static double cosh(double a)
```

acosh
```
public static double acosh(double a)
```

tanh
```
public static double tanh(double a)
```

atanh
```
public static double atanh(double a)
```

coth
```
public static double coth(double a)
```

acoth
```
public static double acoth(double a)
```

sech
```
public static double sech(double a)
```

asech
```
public static double asech(double a)
```

csch
```
public static double csch(double a)
```

acsch
```
public static double acsch(double a)
```

checkPrecision

public static int checkPrecision(double number)

checkPrecision

public static int checkPrecision(float number)

truncate

public static double truncate(double xDouble,
                              int trunc)

truncate

public static float truncate(float xFloat,
                             int trunc)

isInfinity

public static boolean isInfinity(double x)

isInfinity

public static boolean isInfinity(float x)

isPlusInfinity

public static boolean isPlusInfinity(double x)

isPlusInfinity

public static boolean isPlusInfinity(float x)

isMinusInfinity

public static boolean isMinusInfinity(double x)

isMinusInfinity

public static boolean isMinusInfinity(float x)

isNaN

public static boolean isNaN(double x)

isNaN
```
public static boolean isNaN(float x)
```

isEqual

public static boolean isEqual(double x,
                              double y)

isEqual

public static boolean isEqual(float x,
                              float y)

isEqual

public static boolean isEqual(int x,
                              int y)

isEqual

public static boolean isEqual(char x,
                              char y)

isEqual

public static boolean isEqual(java.lang.String x,
                              java.lang.String y)

isEqualWithinLimits

public static boolean isEqualWithinLimits(double x,
                                          double y,
                                          double limit)

isEqualWithinLimits

public static boolean isEqualWithinLimits(float x,
                                          float y,
                                          float limit)

isEqualWithinLimits

public static boolean isEqualWithinLimits(long x,
                                          long y,
                                          long limit)

isEqualWithinLimits

public static boolean isEqualWithinLimits(int x,
                                          int y,
                                          int limit)

isEqualWithinLimits

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

isEqualWithinLimits

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

isEqualWithinPerCent

public static boolean isEqualWithinPerCent(double x,
                                           double y,
                                           double perCent)

isEqualWithinPerCent

public static boolean isEqualWithinPerCent(float x,
                                           float y,
                                           float perCent)

isEqualWithinPerCent

public static boolean isEqualWithinPerCent(long x,
                                           long y,
                                           double perCent)

isEqualWithinPerCent

public static boolean isEqualWithinPerCent(long x,
                                           long y,
                                           long perCent)

isEqualWithinPerCent

public static boolean isEqualWithinPerCent(int x,
                                           int y,
                                           double perCent)

isEqualWithinPerCent

public static boolean isEqualWithinPerCent(int x,
                                           int y,
                                           int perCent)

isEqualWithinPerCent

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

isEqualWithinPerCent

public static boolean isEqualWithinPerCent(java.math.BigInteger x,
                                           java.math.BigInteger y,
                                           java.math.BigDecimal perCent)

isEqualWithinPerCent

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

compare

public static int compare(double x,
                          double y)

compare

public static int compare(int x,
                          int y)

compare

public static int compare(long x,
                          long y)

compare

public static int compare(float x,
                          float y)

compare

public static int compare(byte x,
                          byte y)

compare

public static int compare(short x,
                          short y)

compare

public static boolean compare(double[] array1,
                              double[] array2)

compare

public static boolean compare(float[] array1,
                              float[] array2)

compare

public static boolean compare(int[] array1,
                              int[] array2)

compare

public static boolean compare(long[] array1,
                              long[] array2)

isInteger

public static boolean isInteger(double x)

isInteger

public static boolean isInteger(double[] x)

isInteger

public static boolean isInteger(float x)

isInteger

public static boolean isInteger(float[] x)

isInteger

public static boolean isInteger(java.lang.Number numberAsObject)

isInteger

public static boolean isInteger(java.lang.Number[] numberAsObject)

isEven
```
public static boolean isEven(int x)
```

isEven

public static boolean isEven(float x)

isEven

public static boolean isEven(double x)

isOdd
```
public static boolean isOdd(int x)
```

isOdd
```
public static boolean isOdd(float x)
```

isOdd

public static boolean isOdd(double x)

leapYear

public static boolean leapYear(int year)

dateToJavaMilliS

public static long dateToJavaMilliS(int year,
                                    int month,
                                    int day,
                                    int hour,
                                    int min,
                                    int sec)

maximum

public static double maximum(double[] aa)

maximum

public static float maximum(float[] aa)

maximum
```
public static int maximum(int[] aa)
```

maximum

public static long maximum(long[] aa)

minimum

public static double minimum(double[] aa)

minimum

public static float minimum(float[] aa)

minimum
```
public static int minimum(int[] aa)
```

minimum

public static long minimum(long[] aa)

maximumDifference

public static double maximumDifference(double[] aa)

maximumDifference

public static float maximumDifference(float[] aa)

maximumDifference

public static long maximumDifference(long[] aa)

maximumDifference

public static int maximumDifference(int[] aa)

minimumDifference

public static double minimumDifference(double[] aa)

minimumDifference

public static float minimumDifference(float[] aa)

minimumDifference

public static long minimumDifference(long[] aa)

minimumDifference

public static int minimumDifference(int[] aa)

reverseArray

public static double[] reverseArray(double[] aa)

reverseArray

public static float[] reverseArray(float[] aa)

reverseArray

public static int[] reverseArray(int[] aa)

reverseArray

public static long[] reverseArray(long[] aa)

reverseArray

public static char[] reverseArray(char[] aa)

arrayAbs

public static double[] arrayAbs(double[] aa)

arrayAbs

public static float[] arrayAbs(float[] aa)

arrayAbs

public static long[] arrayAbs(long[] aa)

arrayAbs

public static int[] arrayAbs(int[] aa)

arrayMultByConstant

public static double[] arrayMultByConstant(double[] aa,
                                           double constant)

arrayMultByConstant

public static double[] arrayMultByConstant(int[] aa,
                                           double constant)

arrayMultByConstant

public static double[] arrayMultByConstant(double[] aa,
                                           int constant)

arrayMultByConstant

public static double[] arrayMultByConstant(int[] aa,
                                           int constant)

log10Elements

public static double[] log10Elements(double[] aa)

log10Elements

public static float[] log10Elements(float[] aa)

lnElements

public static double[] lnElements(double[] aa)

lnElements

public static float[] lnElements(float[] aa)

squareRootElements

public static double[] squareRootElements(double[] aa)

squareRootElements

public static float[] squareRootElements(float[] aa)

raiseElementsToPower

public static double[] raiseElementsToPower(double[] aa,
                                            double power)

raiseElementsToPower

public static double[] raiseElementsToPower(double[] aa,
                                            int power)

raiseElementsToPower

public static float[] raiseElementsToPower(float[] aa,
                                           float power)

raiseElementsToPower

public static float[] raiseElementsToPower(float[] aa,
                                           int power)

invertElements

public static double[] invertElements(double[] aa)

invertElements

public static float[] invertElements(float[] aa)

indicesOf

public static int[] indicesOf(double[] array,
                              double value)

indicesOf

public static int[] indicesOf(float[] array,
                              float value)

indicesOf

public static int[] indicesOf(long[] array,
                              long value)

indicesOf

public static int[] indicesOf(int[] array,
                              int value)

indicesOf

public static int[] indicesOf(short[] array,
                              short value)

indicesOf

public static int[] indicesOf(byte[] array,
                              byte value)

indicesOf

public static int[] indicesOf(char[] array,
                              char value)

indicesOf

public static int[] indicesOf(java.lang.String[] array,
                              java.lang.String value)

indicesOf

public static int[] indicesOf(java.lang.Object[] array,
                              java.lang.Object value)

indexOf

public static int indexOf(double[] array,
                          double value)

indexOf

public static int indexOf(float[] array,
                          float value)

indexOf

public static int indexOf(long[] array,
                          long value)

indexOf

public static int indexOf(int[] array,
                          int value)

indexOf

public static int indexOf(byte[] array,
                          byte value)

indexOf

public static int indexOf(short[] array,
                          short value)

indexOf

public static int indexOf(char[] array,
                          char value)

indexOf

public static int indexOf(java.lang.String[] array,
                          java.lang.String value)

indexOf

public static int indexOf(java.lang.Object[] array,
                          java.lang.Object value)

nearestElementValue

public static double nearestElementValue(double[] array,
                                         double value)

nearestElementIndex

public static int nearestElementIndex(double[] array,
                                      double value)

nearestLowerElementValue

public static double nearestLowerElementValue(double[] array,
                                              double value)

nearestLowerElementIndex

public static int nearestLowerElementIndex(double[] array,
                                           double value)

nearestHigherElementValue

public static double nearestHigherElementValue(double[] array,
                                               double value)

nearestHigherElementIndex

public static int nearestHigherElementIndex(double[] array,
                                            double value)

nearestElementValue

public static int nearestElementValue(int[] array,
                                      int value)

nearestElementIndex

public static int nearestElementIndex(int[] array,
                                      int value)

nearestLowerElementValue

public static int nearestLowerElementValue(int[] array,
                                           int value)

nearestLowerElementIndex

public static int nearestLowerElementIndex(int[] array,
                                           int value)

nearestHigherElementValue

public static int nearestHigherElementValue(int[] array,
                                            int value)

nearestHigherElementIndex

public static int nearestHigherElementIndex(int[] array,
                                            int value)

arraySum

public static double arraySum(double[] array)

arraySum

public static float arraySum(float[] array)

arraySum

public static int arraySum(int[] array)

arraySum

public static long arraySum(long[] array)

arrayPositiveElementsSum

public static long arrayPositiveElementsSum(long[] array)

arrayProduct

public static double arrayProduct(double[] array)

arrayProduct

public static float arrayProduct(float[] array)

arrayProduct

public static int arrayProduct(int[] array)

arrayProduct

public static long arrayProduct(long[] array)

concatenate

public static double[] concatenate(double[] aa,
                                   double[] bb)

concatenate

public static float[] concatenate(float[] aa,
                                  float[] bb)

concatenate

public static int[] concatenate(int[] aa,
                                int[] bb)

concatenate

public static long[] concatenate(long[] aa,
                                 long[] bb)

concatenate

public static short[] concatenate(short[] aa,
                                  short[] bb)

concatenate

public static byte[] concatenate(byte[] aa,
                                 byte[] bb)

concatenate

public static char[] concatenate(char[] aa,
                                 char[] bb)

concatenate

public static java.lang.String[] concatenate(java.lang.String[] aa,
                                             java.lang.String[] bb)

concatenate

public static java.lang.Object[] concatenate(java.lang.Object[] aa,
                                             java.lang.Object[] bb)

floatTOdouble

public static double[] floatTOdouble(float[] aa)

intTOdouble

public static double[] intTOdouble(int[] aa)

intTOfloat

public static float[] intTOfloat(int[] aa)

intTOlong

public static long[] intTOlong(int[] aa)

longTOdouble

public static double[] longTOdouble(long[] aa)

longTOfloat

public static float[] longTOfloat(long[] aa)

shortTOdouble

public static double[] shortTOdouble(short[] aa)

shortTOfloat

public static float[] shortTOfloat(short[] aa)

shortTOlong

public static long[] shortTOlong(short[] aa)

shortTOint

public static int[] shortTOint(short[] aa)

byteTOdouble

public static double[] byteTOdouble(byte[] aa)

byteTOfloat

public static float[] byteTOfloat(byte[] aa)

byteTOlong

public static long[] byteTOlong(byte[] aa)

byteTOint

public static int[] byteTOint(byte[] aa)

byteTOshort

public static short[] byteTOshort(byte[] aa)

doubleTOint

public static int[] doubleTOint(double[] aa)

print

public static void print(double[] aa)

println

public static void println(double[] aa)

print
```
public static void print(float[] aa)
```

println

public static void println(float[] aa)

print
```
public static void print(int[] aa)
```

println
```
public static void println(int[] aa)
```

print
```
public static void print(long[] aa)
```

println

public static void println(long[] aa)

print
```
public static void print(char[] aa)
```

println

public static void println(char[] aa)

print

public static void print(java.lang.String[] aa)

println

public static void println(java.lang.String[] aa)

print
```
public static void print(short[] aa)
```

println

public static void println(short[] aa)

print
```
public static void print(byte[] aa)
```

println

public static void println(byte[] aa)

print

public static void print(double[][] aa)

selectSortVector

public static java.util.Vector<java.lang.Object> selectSortVector(double[] aa)

selectSortArrayList

public static java.util.ArrayList<java.lang.Object> selectSortArrayList(double[] aa)

selectionSort

public static double[] selectionSort(double[] aa)

selectionSort

public static float[] selectionSort(float[] aa)

selectionSort

public static int[] selectionSort(int[] aa)

selectionSort

public static long[] selectionSort(long[] aa)

selectionSort

public static void selectionSort(double[] aa,
                                 double[] bb,
                                 int[] indices)

selectionSort

public static void selectionSort(double[] aa,
                                 double[] bb,
                                 double[] cc,
                                 double[] dd)

selectionSort

public static void selectionSort(float[] aa,
                                 float[] bb,
                                 float[] cc,
                                 float[] dd)

selectionSort

public static void selectionSort(long[] aa,
                                 long[] bb,
                                 long[] cc,
                                 long[] dd)

selectionSort

public static void selectionSort(int[] aa,
                                 int[] bb,
                                 int[] cc,
                                 int[] dd)

selectionSort

public static void selectionSort(double[] aa,
                                 long[] bb,
                                 double[] cc,
                                 long[] dd)

selectionSort

public static void selectionSort(long[] aa,
                                 double[] bb,
                                 long[] cc,
                                 double[] dd)

selectionSort

public static void selectionSort(double[] aa,
                                 int[] bb,
                                 double[] cc,
                                 int[] dd)

selectionSort

public static void selectionSort(int[] aa,
                                 double[] bb,
                                 int[] cc,
                                 double[] dd)

selectionSort

public static void selectionSort(long[] aa,
                                 int[] bb,
                                 long[] cc,
                                 int[] dd)

selectionSort

public static void selectionSort(int[] aa,
                                 long[] bb,
                                 int[] cc,
                                 long[] dd)

selectSort

public static void selectSort(double[] aa,
                              double[] bb,
                              int[] indices)

copy

public static double[] copy(double[] array)

copy

public static float[] copy(float[] array)

copy

public static int[] copy(int[] array)

copy

public static long[] copy(long[] array)

copy

public static double[][] copy(double[][] array)

copy

public static float[][] copy(float[][] array)

copy

public static int[][] copy(int[][] array)

copy

public static long[][] copy(long[][] array)

copy

public static double[][][] copy(double[][][] array)

copy

public static float[][][] copy(float[][][] array)

copy

public static int[][][] copy(int[][][] array)

copy

public static long[][][] copy(long[][][] array)

copy

public static double[][][][] copy(double[][][][] array)

copy

public static float[][][][] copy(float[][][][] array)

copy

public static int[][][][] copy(int[][][][] array)

copy

public static long[][][][] copy(long[][][][] array)

copy

public static java.lang.String[] copy(java.lang.String[] array)

copy

public static java.lang.String[][] copy(java.lang.String[][] array)

copy

public static java.lang.String[][][] copy(java.lang.String[][][] array)

copy

public static java.lang.String[][][][] copy(java.lang.String[][][][] array)

copy

public static boolean[] copy(boolean[] array)

copy

public static boolean[][] copy(boolean[][] array)

copy

public static boolean[][][] copy(boolean[][][] array)

copy

public static boolean[][][][] copy(boolean[][][][] array)

copy

public static char[] copy(char[] array)

copy

public static char[][] copy(char[][] array)

copy

public static char[][][] copy(char[][][] array)

copy

public static char[][][][] copy(char[][][][] array)

copy

public static java.lang.Object copy(java.lang.Object obj)

copyObject

public static java.lang.Object copyObject(java.lang.Object obj)

radToDeg

public static double radToDeg(double rad)

degToRad

public static double degToRad(double deg)

frequencyToRadialFrequency

public static double frequencyToRadialFrequency(double frequency)

radialFrequencyToFrequency

public static double radialFrequencyToFrequency(double radial)

evToNm

public static double evToNm(double ev)

nmToEv

public static double nmToEv(double nm)

molarToPercentWeightByVol

public static double molarToPercentWeightByVol(double molar,
                                               double molWeight)

percentWeightByVolToMolar

public static double percentWeightByVolToMolar(double perCent,
                                               double molWeight)

celsiusToKelvin

public static double celsiusToKelvin(double cels)

kelvinToCelsius

public static double kelvinToCelsius(double kelv)

celsiusToFahren

public static double celsiusToFahren(double cels)

fahrenToCelsius

public static double fahrenToCelsius(double fahr)

calorieToJoule

public static double calorieToJoule(double cal)

jouleToCalorie

public static double jouleToCalorie(double joule)

gramToOunce

public static double gramToOunce(double gm)

ounceToGram

public static double ounceToGram(double oz)

kgToPound

public static double kgToPound(double kg)

poundToKg

public static double poundToKg(double pds)

kgToTon

public static double kgToTon(double kg)

tonToKg

public static double tonToKg(double tons)

millimetreToInch

public static double millimetreToInch(double mm)

inchToMillimetre

public static double inchToMillimetre(double in)

footToMetre

public static double footToMetre(double ft)

metreToFoot

public static double metreToFoot(double metre)

yardToMetre

public static double yardToMetre(double yd)

metreToYard

public static double metreToYard(double metre)

mileToKm

public static double mileToKm(double mile)

kmToMile

public static double kmToMile(double km)

gallonToLitre

public static double gallonToLitre(double gall)

litreToGallon

public static double litreToGallon(double litre)

quartToLitre

public static double quartToLitre(double quart)

litreToQuart

public static double litreToQuart(double litre)

pintToLitre

public static double pintToLitre(double pint)

litreToPint

public static double litreToPint(double litre)

gallonPerMileToLitrePerKm

public static double gallonPerMileToLitrePerKm(double gallPmile)

litrePerKmToGallonPerMile

public static double litrePerKmToGallonPerMile(double litrePkm)

milePerGallonToKmPerLitre

public static double milePerGallonToKmPerLitre(double milePgall)

kmPerLitreToMilePerGallon

public static double kmPerLitreToMilePerGallon(double kmPlitre)

fluidOunceUKtoUS

public static double fluidOunceUKtoUS(double flOzUK)

fluidOunceUStoUK

public static double fluidOunceUStoUK(double flOzUS)

pintUKtoUS

public static double pintUKtoUS(double pintUK)

pintUStoUK

public static double pintUStoUK(double pintUS)

quartUKtoUS

public static double quartUKtoUS(double quartUK)

quartUStoUK

public static double quartUStoUK(double quartUS)

gallonUKtoUS

public static double gallonUKtoUS(double gallonUK)

gallonUStoUK

public static double gallonUStoUK(double gallonUS)

pintUKtoCupUS

public static double pintUKtoCupUS(double pintUK)

cupUStoPintUK

public static double cupUStoPintUK(double cupUS)

calcBMImetric

public static double calcBMImetric(double height,
                                   double weight)

calcBMIimperial

public static double calcBMIimperial(double height,
                                     double weight)

calcWeightFromBMImetric

public static double calcWeightFromBMImetric(double bmi,
                                             double height)

calcWeightFromBMIimperial

public static double calcWeightFromBMIimperial(double bmi,
                                               double height)

Skip navigation links

All Classes

Summary:
Nested |
Field |
Constr |
Method

Detail:
Field |
Constr |
Method

Class Fmath

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

N_AVAGADRO

K_BOLTZMANN

H_PLANCK

H_PLANCK_RED

C_LIGHT

R_GAS

F_FARADAY

T_ABS

Q_ELECTRON

M_ELECTRON

M_PROTON

M_NEUTRON

EPSILON_0

MU_0

ETA_0

EULER_CONSTANT_GAMMA

PI

E

Constructor Detail

Fmath

Method Detail

log10

log10

antilog10

antilog10

log

log

antilog

antilog

log2

log2

antilog2

antilog2

log10

log10

log10

log10

square

square

square

square

square

square

factorial

factorial

factorial

factorial

factorial

logFactorial

logFactorial

logFactorial

sign

sign

sign

sign

hypot

hypot

angle

angle

sin

sin

sin

asin

cos

cos

cos

acos

tan

tan

tan

atan

atan2

cot

acot