JSci.maths.MathDouble Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jsci Show documentation
Show all versions of jsci Show documentation
JSci is a set of open source Java packages. The aim is to encapsulate scientific methods/principles in the most natural way possible. As such they should greatly aid the development of scientific based software.
It offers: abstract math interfaces, linear algebra (support for various matrix and vector types), statistics (including probability distributions), wavelets, newtonian mechanics, chart/graph components (AWT and Swing), MathML DOM implementation, ...
Note: some packages, like javax.comm, for the astro and instruments package aren't listed as dependencies (not available).
The newest version!
package JSci.maths;
import java.lang.Comparable;
import java.lang.Double;
import JSci.GlobalSettings;
import JSci.maths.groups.AbelianGroup;
import JSci.maths.fields.*;
/**
* The MathDouble class encapsulates double numbers.
* Methods will automatically promote objects from subsets.
* @see JSci.maths.fields.RealField
* @version 1.1
* @author Mark Hale
*/
public final class MathDouble extends Number implements Comparable, Field.Member {
private static final long serialVersionUID = 8616680319093653108L;
private final double x;
/**
* Constructs a double number.
*/
public MathDouble(final double num) {
x=num;
}
/**
* Constructs the double number represented by a string.
* @param s a string representing a double number.
* @exception NumberFormatException if the string does not contain a parsable number.
*/
public MathDouble(final String s) throws NumberFormatException {
x=Double.parseDouble(s);
}
/**
* Compares two numbers for equality.
* @param obj a number.
*/
public boolean equals(Object obj) {
return equals(obj, GlobalSettings.ZERO_TOL);
}
public boolean equals(Object obj, double tol) {
if(obj instanceof Number) {
return Math.abs(x-((Number)obj).doubleValue()) <= tol;
} else
return false;
}
public int hashCode() {
return (int) x;
}
/**
* Compares two numbers.
* @param obj a number.
* @return a negative value if this<obj,
* zero if this==obj,
* and a positive value if this>obj.
*/
public int compareTo(Object obj) throws IllegalArgumentException {
if(obj!=null && (obj instanceof Number)) {
double objValue = ((Number)obj).doubleValue();
if(Math.abs(x-objValue) <= GlobalSettings.ZERO_TOL) {
return 0;
} else {
return (x < objValue ? -1 : 1);
}
} else
throw new IllegalArgumentException("Invalid object: "+obj.getClass());
}
/**
* Returns a string representing the value of this double number.
*/
public String toString() {
return Double.toString(x);
}
/**
* Returns the double value.
*/
public double value() {
return x;
}
public int intValue() {
return (int) x;
}
public long longValue() {
return (long) x;
}
public float floatValue() {
return (float) x;
}
public double doubleValue() {
return x;
}
/**
* Returns true if the number is within the zero tolerance.
*/
public static boolean isZero(double x) {
return (Math.abs(x) <= GlobalSettings.ZERO_TOL);
}
/**
* Returns true if this number is NaN.
*/
public boolean isNaN() {
return (x==Double.NaN);
}
/**
* Returns true if this number is infinite.
*/
public boolean isInfinite() {
return (x==Double.POSITIVE_INFINITY) || (x==Double.NEGATIVE_INFINITY);
}
public Object getSet() {
return RealField.getInstance();
}
/**
* Returns the negative of this number.
*/
public AbelianGroup.Member negate() {
return new MathDouble(-x);
}
/**
* Returns the inverse of this number.
*/
public Field.Member inverse() {
return new MathDouble(1.0/x);
}
/**
* Returns the addition of this number and another.
*/
public AbelianGroup.Member add(final AbelianGroup.Member n) {
if(n instanceof Number)
return add(((Number)n).doubleValue());
else
throw new IllegalArgumentException("Member class not recognised by this method: "+n.getClass());
}
/**
* Returns the addition of this double number and another.
*/
public MathDouble add(final MathDouble n) {
return add(n.x);
}
public MathDouble add(double y) {
return new MathDouble(x+y);
}
/**
* Returns the subtraction of this number and another.
*/
public AbelianGroup.Member subtract(final AbelianGroup.Member n) {
if(n instanceof Number)
return subtract(((Number)n).doubleValue());
else
throw new IllegalArgumentException("Member class not recognised by this method: "+n.getClass());
}
/**
* Returns the subtraction of this double number and another.
*/
public MathDouble subtract(final MathDouble n) {
return subtract(n.x);
}
public MathDouble subtract(double y) {
return new MathDouble(x-y);
}
/**
* Returns the multiplication of this number and another.
*/
public Ring.Member multiply(final Ring.Member n) {
if(n instanceof Number)
return multiply(((Number)n).doubleValue());
else
throw new IllegalArgumentException("Member class not recognised by this method: "+n.getClass());
}
/**
* Returns the multiplication of this double number and another.
*/
public MathDouble multiply(final MathDouble n) {
return multiply(n.x);
}
public MathDouble multiply(double y) {
return new MathDouble(x*y);
}
/**
* Returns the division of this number and another.
*/
public Field.Member divide(final Field.Member n) {
if(n instanceof Number)
return divide(((Number)n).doubleValue());
else
throw new IllegalArgumentException("Member class not recognised by this method: "+n.getClass());
}
/**
* Returns the division of this double number and another.
*/
public MathDouble divide(final MathDouble n) {
return divide(n.x);
}
public MathDouble divide(double y) {
return new MathDouble(x/y);
}
//===========
// FUNCTIONS
//===========
// EXP
/**
* Returns the exponential number e(2.718...) raised to the power of a number.
*/
public static MathDouble exp(final MathDouble x) {
return exp(x.x);
}
public static MathDouble exp(Number x) {
return exp(x.doubleValue());
}
public static MathDouble exp(double x) {
return new MathDouble(Math.exp(x));
}
// LOG
/**
* Returns the natural logarithm (base e) of a number.
*/
public static MathDouble log(final MathDouble x) {
return log(x.x);
}
public static MathDouble log(Number x) {
return log(x.doubleValue());
}
public static MathDouble log(double x) {
return new MathDouble(Math.log(x));
}
// SIN
/**
* Returns the trigonometric sine of an angle.
* @param x an angle that is measured in radians
*/
public static MathDouble sin(final MathDouble x) {
return sin(x.x);
}
public static MathDouble sin(Number x) {
return sin(x.doubleValue());
}
public static MathDouble sin(double x) {
return new MathDouble(Math.sin(x));
}
// COS
/**
* Returns the trigonometric cosine of an angle.
* @param x an angle that is measured in radians
*/
public static MathDouble cos(final MathDouble x) {
return cos(x.x);
}
public static MathDouble cos(Number x) {
return cos(x.doubleValue());
}
public static MathDouble cos(double x) {
return new MathDouble(Math.cos(x));
}
// TAN
/**
* Returns the trigonometric tangent of an angle.
* @param x an angle that is measured in radians
*/
public static MathDouble tan(final MathDouble x) {
return tan(x.x);
}
public static MathDouble tan(Number x) {
return tan(x.doubleValue());
}
public static MathDouble tan(double x) {
return new MathDouble(Math.tan(x));
}
// SINH
/**
* Returns the hyperbolic sine of a number.
*/
public static MathDouble sinh(final MathDouble x) {
return sinh(x.x);
}
public static MathDouble sinh(Number x) {
return sinh(x.doubleValue());
}
public static MathDouble sinh(double x) {
return new MathDouble(ExtraMath.sinh(x));
}
// COSH
/**
* Returns the hyperbolic cosine of a number.
*/
public static MathDouble cosh(final MathDouble x) {
return cosh(x.x);
}
public static MathDouble cosh(Number x) {
return cosh(x.doubleValue());
}
public static MathDouble cosh(double x) {
return new MathDouble(ExtraMath.cosh(x));
}
// TANH
/**
* Returns the hyperbolic tangent of a number.
*/
public static MathDouble tanh(final MathDouble x) {
return tanh(x.x);
}
public static MathDouble tanh(Number x) {
return tanh(x.doubleValue());
}
public static MathDouble tanh(double x) {
return new MathDouble(ExtraMath.tanh(x));
}
// INVERSE SIN
/**
* Returns the arc sine of a number.
*/
public static MathDouble asin(final MathDouble x) {
return asin(x.x);
}
public static MathDouble asin(Number x) {
return asin(x.doubleValue());
}
public static MathDouble asin(double x) {
return new MathDouble(Math.asin(x));
}
// INVERSE COS
/**
* Returns the arc cosine of a number.
*/
public static MathDouble acos(final MathDouble x) {
return acos(x.x);
}
public static MathDouble acos(Number x) {
return acos(x.doubleValue());
}
public static MathDouble acos(double x) {
return new MathDouble(Math.acos(x));
}
// INVERSE TAN
/**
* Returns the arc tangent of a number.
*/
public static MathDouble atan(final MathDouble x) {
return atan(x.x);
}
public static MathDouble atan(Number x) {
return atan(x.doubleValue());
}
public static MathDouble atan(double x) {
return new MathDouble(Math.atan(x));
}
// INVERSE SINH
/**
* Returns the arc hyperbolic sine of a number.
*/
public static MathDouble asinh(final MathDouble x) {
return asinh(x.x);
}
public static MathDouble asinh(Number x) {
return asinh(x.doubleValue());
}
public static MathDouble asinh(double x) {
return new MathDouble(ExtraMath.asinh(x));
}
// INVERSE COSH
/**
* Returns the arc hyperbolic cosine of a number.
*/
public static MathDouble acosh(final MathDouble x) {
return acosh(x.x);
}
public static MathDouble acosh(Number x) {
return acosh(x.doubleValue());
}
public static MathDouble acosh(double x) {
return new MathDouble(ExtraMath.acosh(x));
}
// INVERSE TANH
/**
* Returns the arc hyperbolic tangent of a number.
*/
public static MathDouble atanh(final MathDouble x) {
return atanh(x.x);
}
public static MathDouble atanh(Number x) {
return atanh(x.doubleValue());
}
public static MathDouble atanh(double x) {
return new MathDouble(ExtraMath.atanh(x));
}
}