Rational

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.rubecula.jquantity
Class Rational

java.lang.Object
  com.rubecula.util.Item
      com.rubecula.jquantity.BaseNumber
          com.rubecula.jquantity.MutableNumber
              com.rubecula.jquantity.DivisibleMutable
                  com.rubecula.jquantity.Rational

All Implemented Interfaces:: Arithmetical, Arithmutable, Auditable, java.lang.Cloneable, java.lang.Comparable, Divisible, Estimable, Fuzzy, FuzzyMutable, Identifiable, Millable, Mutable, Nameable, Normalizable, Presentable, java.io.Serializable, Trigonometrical

Direct Known Subclasses:: Value

public class Rational
extends DivisibleMutable
implements Estimable, FuzzyMutable, Trigonometrical, Normalizable

Public class to represent precise rational numbers. What's wrong with BigDecimal, you might ask? BigDecimal can only represent rational numbers where the denominator is a power of ten. Many numbers are just not like that.
Furthermore, both numerator and denominator can be either exact integers (i.e. Manifests or WholeNumbers) or fuzzy integers (i.e. FuzzInt) so that Rational can itself represent a complete range of potentially fuzzy numbers. Infinity is a legal Rational number.

Version:: $Revision: 1.62 $ // TODO Needs more conformance checking. // TODO There are really too many constructors for this class. // TODO The javadoc for other interface methods should be done like for Arithmutable.
Author:: Robin Hillyard
See Also:: Serialized Form

Nested Class Summary
`private class`	`Rational.RationalException`
`class`	`Rational.RValueException` Title: RValueException Description: Checked exception class for Rational.

Field Summary
`protected BaseNumber`	`_Denominator` _Denominator is the denominator of the rational quantity defined by this.
`protected double`	`_Estimate` _Estimate is the best estimate of the value (STRICTLY for debugging purposes only).
`protected BaseNumber`	`_Numerator` _Numerator is the numerator of the rational quantity defined by this.
`(package private) static Rational`	`$_c` By definition, the velocity of light (in meter/second).
`(package private) static Rational`	`$_degF` Degrees Fahrenheit/Celsius offset: 32.
`static Rational`	`$_degR` Degrees Rankine/Kelvin conversion: 5/9.
`(package private) static Rational`	`$_g` By definition, the standard (mean) gravity at the Earth's surface: 9.80665.
`static Rational`	`$_Log10_E`
`(package private) static Rational`	`$_Pi_2`
`(package private) static Rational`	`$_Pi_4`
`(package private) static Rational`	`$_Tan15Deg` 2 - $Rt3.
`(package private) static Rational`	`$_Tan22_5Deg` 1 / (1 + Rt2).
`(package private) static Rational`	`$_Tan30Deg` 1/$Rt3.
`static Rational`	`$0` $0 is the Rational representation of the exact value 0.
`static Rational`	`$1` $1 is the Rational representation of the exact value 1.
`static Rational`	`$1_2` $1_2 is the Rational representation of the exact value 1/2.
`static Rational`	`$10` $10 is the Rational representation of the exact value 10.
`(package private) static Rational`	`$12`
`static Rational`	`$2` $2 is the Rational representation of the exact value 2.
`static Rational`	`$3`
`(package private) static Rational`	`$6`
`static Rational`	`$E` Value of E as a Rational.
`static Rational`	`$Infinity` $Infinity is the Rational representation of the (exact) value of infinity, i.e. 1/0.
`(package private) static Rational`	`$NaN`
`static Rational`	`$Pi` Value of Pi as a Rational.
`(package private) static Rational`	`$Rt2` InitialValueOf($S_Rt2).
`(package private) static Rational`	`$Rt3` InitialValueOf($S_Rt3).
`(package private) static Rational`	`$Rt5` InitialValueOf($S_Rt5).
`(package private) static java.lang.String`	`$S_Rt2` 1.414213562373095048801688724209698078569671875377
`(package private) static java.lang.String`	`$S_Rt3` 1.732050807568877293527446341505872366942805253810
`(package private) static java.lang.String`	`$S_Rt5` 2.2360679774997896964091736687312762354406183596
`private static int`	`MAX_RATIO_BITS`
`private static double`	`PRESENTATION_TOLERANCE`

Fields inherited from class com.rubecula.jquantity.MutableNumber

$__1

Fields inherited from class com.rubecula.jquantity.BaseNumber

Fields inherited from class com.rubecula.util.Item

JQUANTITY_TEST

Fields inherited from interface com.rubecula.jquantity.Fuzzy

$DistGaussian, $DistInvalid, $DistNone, $DistUniform, $Names

Constructor Summary
	`Rational()` Empty constructor to make an undefined Rational object.
`(package private)`	`Rational(java.math.BigDecimal x)`
`protected`	`Rational(java.math.BigDecimal x, java.lang.String identifier)` Factory method to create a Rational from a BigDecimal value and an identifier.
	`Rational(Integral value)` Constructs a non-explicitly identified Rational representing the ratio of value divided by unity.
	`Rational(Integral numerator, Integral denominator)` Constructs a non-explicitly identified, normalized Rational representing the ratio of numerator divided by denominator.
`protected`	`Rational(Integral numerator, Integral denominator, boolean normalize)` Constructs a non-explicitly identified Rational representing the ratio of numerator divided by denominator, with optional normalization.
`protected`	`Rational(Integral numerator, Integral denominator, boolean normalize, java.lang.String identifier)` Constructs an identified Rational representing the ratio of numerator divided by denominator, with optional normalization.
	`Rational(Integral numerator, Integral denominator, java.lang.String identifier)` Constructs an identified Rational representing the ratio of numerator divided by denominator.
	`Rational(Integral numerator, java.lang.String identifier)` Constructs an identified Rational representing the ratio of numerator divided by denominator, with optional normalization.
	`Rational(long numerator, long denominator)` Convenience constructor for two longs.
`protected`	`Rational(Rational source)` Constructor to make a copy of a Rational object.
	`Rational(java.lang.String string)` Secondary constructor to create a Rational from a String.

Method Summary
`Rational`	`absRational()` Method to yield the absolute (unsigned) value of this as a Rational.
`void`	`add(BaseNumber that)` MUTATING Instance method to add another Arithmetical into this object.
`protected void`	`addAbsError(double absBound, int model)` This method is used to add in an intrinsic error bound.
`protected void`	`addTops(Rational other)`
`Trigonometrical`	`arctanX2()` Method to evaluate the arctangent function.
`java.lang.String`	`audit(java.lang.String label)` Method to return a detailed string from an arithmetical object for debugging purposes.
`private static Rational`	`BigDecimalRational(java.math.BigInteger top, java.math.BigInteger bottom, double tolerance, int characteristic, java.lang.String id)` Class method to yield an explicitly identified Rational which approximates top/bottom to within tolerance (to exponent characteristic).
`private static java.math.BigInteger`	`BigTenToPower(int x)` Class method to yield a BigInteger whose value is 10 to the power of x.
`java.lang.Object`	`clone()` Creates and returns a deep copy of this object.
`int`	`compareTo(Integral val)` Compares this Rational with the specified Integral.
`int`	`compareTo(Rational val)` Compares this Rational with the specified Rational.
`protected int`	`compareTo(Rational val, boolean absolute)` Compares this Rational with the specified Rational.
`java.lang.String`	`defaultIdentifier()` Method to yield a default string to identify this object in the event that it has no explicitly defined identifier.
`(package private) Rational`	`differenceRational(Rational subtrahend)` Method to yield the difference of `this` less a BaseNumber (`subtrahend`).
`void`	`divide(BaseNumber that)` MUTATING method to replace this by the sum of this and that
`private java.math.BigInteger[]`	`divideNumeratorAndRemainder(Integral divisor)`
`double`	`doubleValue()` Returns the value of the specified number as a `double`.
`private void`	`ensureDenominatorArithmutable()` MUTATING method to ensure that the numerator is an Arithmutable object.
`private void`	`ensureDenominatorFuzzy()`
`private void`	`ensureNumeratorArithmutable()` MUTATING method to ensure that the numerator is an Arithmutable object.
`private void`	`ensureNumeratorFuzzy()`
`Trigonometrical`	`exp()` Method to evaluate the exponential function.
`protected void`	`factor(Integral divisor)` MUTATING METHOD: Replaces value with `(this / divisor)`.
`Divisible`	`factored(double factor)` Method to yield the quotient of `this` divided by factor, and return it as the result.
`float`	`floatValue()` Returns the value of the specified number as a `float`.
`(package private) Rational`	`fold(Rational range)` Method to force this into a specific range.
`private void`	`forceFuzzy()` MUTATING method to ensure that this Rational is (potentially) fuzzy, that is to say its Numerator must be FuzzyMutable.
`private java.math.BigInteger`	`gcd(boolean strict)`
`private static java.math.BigInteger`	`GetBigInteger(Integral x, boolean strict)`
`long`	`getBottom()` Method to yield the denominator as a long.
`double`	`getBound()` Method to get the relative bound of this Rational.
`private static double`	`GetBound(double x, boolean exact)` Get the bounds for a number in double format which is either exact or accurate only to the number of decimal places given.
`double`	`getBoundAbs()` Method to get the absolute bound of non-fuzzy value.
`protected BaseNumber`	`getDenominator()` Method to access the denominator of this Rational object.
`protected Integral`	`getDenominatorAsIntegral()` Method to access the denominator of this Rational object.
`double`	`getEstimate()` Method to get the current estimate of an arithmetical value.
`int`	`getModel()` Method to get the error distribution model of this non-fuzzy object.
`protected BaseNumber`	`getNumerator()` Method to access the numerator of this Rational object.
`protected Integral`	`getNumeratorAsIntegral()` Method to access the numerator of this Rational object.
`long`	`getTop()` Method to yield the numerator as a long.
`Rational`	`half()` Method to yield half the value of this.
`int`	`hashCode()` Method to determine a hash code for this object. // TODO Surely this isn't a good hash code for Rational objects.
`static Rational`	`InitialValueOf(java.lang.String string)` Create a constant value of a Rational from a string.
`private static Rational`	`InitParse(Presentation presentation, java.lang.String id)`
`private static java.math.BigInteger`	`IntVal(java.math.BigDecimal x)`
`int`	`intValue()` Method to yield the equivalent integer value for this object.
`Divisible`	`inverse()` Method to yield the reciprocal of `this` and return it as the result.
`Rational`	`inverseRational()`
`void`	`invert()` MUTATING Instance method to invert this (i.e. replace this by its reciprocal)
`boolean`	`isExact()` Method to determine if the quantity represented is non-fuzzy;
`boolean`	`isInfinite()` Method to determine if an arithmetical object is infinite.
`boolean`	`isInteger()` Method determines if it is safe and appropriate to convert this arithmetical object into BigInteger.
`(package private) boolean`	`isIntFuzzy()` This method is used to determine if the numerical value of this is convertible to a int, without regard to the precision.
`(package private) boolean`	`isNaN()` Method to determine if this Rational is "not a number".
`boolean`	`isNormal()` Method to determine if this instance is already normalized.
`boolean`	`isUnity()` Method to determine if this arithmetical object has the exact value of 1.
`Trigonometrical`	`log()` Method to evaluate the natural log function.
`long`	`longValue()` Method to yield the equivalent integer value for this object.
`(package private) long`	`longValue(double tolerance)` Method to yield the long value of this object.
`(package private) double`	`magnitude()` Method to yield the magnitude of this Rational as a double.
`static void`	`main(java.lang.String[] args)` Main method for testing this class.
`Presentable`	`makePresentableInstance(Presentation presentation)` Instance method to convert a Presentation into a Presentable.
`protected BaseNumber`	`minus()` Method to yield a copy of `this` but with the sign changed.
`Rational`	`minusRational()` Method to yield a copy of `this` but with the sign changed.
`(package private) Rational`	`modulo(long x)` Method to return the value of this modulo x
`void`	`multiply(BaseNumber that)` MUTATING Instance method to multiply another Arithmetical into this object.
`protected void`	`multiplyTopAndBottom(BaseNumber factor)` MUTATING method to multiply the top and bottom of a rational equally.
`void`	`negate()` MUTATING Instance method to negate this.
`void`	`normalize()` MUTATING instance method to remove any common factors from top and bottom.
`(package private) Rational`	`normalizeToBigDecimal(double tolerance)` Normalize `this` such that the denominator is a power of ten AND the value of the result differs from the value of `this` by not more than the tolerance.
`(package private) Rational`	`normalizeToInt(double tolerance)` Normalize this Rational so that the result: a) has a denominator unity and b) approximates this in value, to within tolerance.
`static Rational`	`Parse(NumberPresentation presentation, java.lang.String identifier)` Translates the NumberPresentation representation into a new Rational.
`static Presentable`	`Parse(Presentation presentation)` Create a Rational from a Presentation and return it as a Presentable.
`protected BaseNumber`	`pow(double power)` Method to yield this raised to a double-precision power.
`protected BaseNumber`	`pow(int power)` Method to raise `this` to the power `power` return the result.
`Rational`	`pow(Rational power)`
`Presentation`	`present(AttrMap attributes)` Convert `this` Presentable object into a Presentation, according to the set of attributes provided.
`private Presentation`	`present(AttrMap attributes, double tolerance)` Method to convert this Rational into an equivalent Presentation.
`private Presentation`	`present(AttrMap attributes, double tolerance, boolean notRatio)` Method to convert this Rational into an equivalent Presentation.
`private Presentation`	`present(double tolerance)` Method to convert this Rational into an equivalent Presentation.
`private Presentation`	`presentRatio()` Method to convert this Rational into the appropriate NumberPresentation as a ratio rather than as a decimal.
`Rational`	`productRational(Rational multiplicand)` Method to multiply `multiplicand` to `this` and return their product as the result.
`Divisible`	`quotient(BaseNumber divisor)` Method to divide `this` by `multiplicand` and return the quotient as the result.
`(package private) Rational`	`quotientRational(Rational that)`
`void`	`raiseToPower(int power)` MUTATING Instance method to raise this to power x.
`(package private) Rational`	`root(int p)` method root: to yield an exact (integer) Rational for the root of a positive integral Rational.
`private static BaseNumber`	`SafeReference(BaseNumber x)` This method yields a reference to a BaseNumber (the numerator or denominator) for the purpose of cloning/copying a Rational object safely.
`void`	`scale(double factor)` MUTATING Instance method to multiply this by a (double) scale factor
`void`	`scale(long factor)` MUTATING Instance method to multiply this by a scale factor.
`protected BaseNumber`	`scaled(long multiplicand)` Method to multiply `multiplicand` by `this` and return their product as the result.
`void`	`setBound(double bound)` MUTATING Method to set the relative bound of fuzzy value.
`protected void`	`setBoundAbs(double bound)` MUTATING Method to set the absolute bound of fuzzy value. // TODO Move this down with the protected methods (not defined by FuzzyMutable).
`private void`	`setDenominator(BaseNumber denominator)` MUTATING method to set the value of the denominator.
`private void`	`setDenominator(Integral denominator)` MUTATING method to set the value of the denominator.
`private void`	`setExact()`
`void`	`setModel(int model)` MUTATING Method to set the error distribution model.
`private void`	`setNumerator(BaseNumber numerator)` MUTATING method to set the value of the numerator.
`private void`	`setNumerator(Integral numerator)` MUTATING method to set the value of the numerator.
`int`	`signum()` Method to find the sign of the magnitude of this arithmetical object.
`(package private) Rational`	`squareRational()` Method to return the Rational formed my multiplying this by itself.
`void`	`subtract(Rational that)` MUTATING method to replace this by the difference of this and that
`Rational`	`sumRational(Rational addend)` Method to add `addend` to `this` and return their sum as the result.
`Trigonometrical`	`tan_theta_2()` Method to evaluate the tangent function.
`(package private) void`	`timesTenToPower(int power)` Package-protected MUTATING method to multiply this by a power of ten.
`(package private) Approximation`	`toApproximation(double tolerance)` Method to convert this Rational into the appropriate Approximation.
`private java.math.BigDecimal`	`toBigDecimal()` Method to yield a BigDecimal instance which approximates `this`.
`private java.math.BigDecimal`	`toBigDecimal(double tolerance)` Method to yield a BigDecimal instance which approximates `this`.
`private java.math.BigDecimal`	`toBigDecimal(int halfPlaces)` Method to yield a BigDecimal instance which approximates `this`.
`Integral`	`toIntegral()` Method to present a Rational as an Integral number.
`java.lang.String`	`toString()` Method to yield a string representing this Rational exactly.
`(package private) java.lang.String`	`toString(double tolerance)` Method to determine a suitable string to represent this Rational, such that the resulting string is precise within tolerance.
`void`	`updateEstimate()` MUTATING method to update the current estimate.
`static Rational`	`valueOf(BaseNumber number)` Factory method to create a Rational from a BaseNumber or, if number is Rational, then to make a copy.
`(package private) static Rational`	`valueOf(java.math.BigInteger integer, java.math.BigInteger fraction, int places)` Factory method to create a (decimal) Rational from two (big) integers.
`static Rational`	`valueOf(double value)` Factory method to create a Rational from an exact double value.
`static Rational`	`valueOf(double value, boolean exact)` Factory method to create a Rational from a double value, that may or not be "exact".
`static Rational`	`valueOf(double value, double bound, int model)` Factory method to create a Rational from a double value, given an indication of precision.
`static Rational`	`valueOf(double value, double bound, int model, java.lang.String identifier)` Factory method to create a Rational from a double value, given an indication of precision.
`static Rational`	`valueOf(double value, int precision, java.lang.String identifier)` Factory method to create a Rational from a double value, given an indication of precision.
`static Rational`	`valueOf(double value, java.lang.String identifier)` Factory method to create a Rational from a double value, using standard double precision and with an explicit identifier.
`static Rational`	`valueOf(float value)` Factory method to create a Rational from a float value, given an explicit identifier.
`static Rational`	`valueOf(float value, java.lang.String identifier)` Factory method to create a Rational from a float value without an explicit identifier.
`static Rational`	`valueOf(Presentation presentation)` Convert Presentation `presentation` into a Rational.
`static BaseNumber`	`valueOf(java.lang.String string)` Convenience factory method to create a new Rational instance from a value string and an implicit identifier (the value string itself).
`static BaseNumber`	`valueOf(java.lang.String string, java.lang.String id)` Convenience factory method to create a new Rational instance from a value string and an explicit identifier.
`(package private) static Rational`	`valueOfExponent(int exponent)` Factory method to create a Rational which is equal to 10^exponent.
`(package private) static Rational`	`valueOfExponent(int exponent, int radix)` Factory method to create a Rational which is equal to radix^exponent.
`(package private) static Rational`	`valueOfExponent(java.lang.String exponentStr, int radix)` Factory method to create a Rational which is equal to the multiplier represented by an exponent string.
`private static BaseNumber`	`WidenIntegral(BaseNumber number)` Method to convert an Integral object into an Arithmutable object if necessary.

Methods inherited from class com.rubecula.jquantity.MutableNumber

assertMutable, factored, forcePositive, getIdentifier, getIdentifier, isLong, isMutable, product, setConstant, setIdentifier, setIdentifierPost, setIdentifierPre, setIdentifierPrePost, sum, test

Methods inherited from class com.rubecula.jquantity.BaseNumber

abs, bestModel, BestModel, byteValue, characteristic, Characteristic, difference, impartFuzziness, isEqual, isUncertain, isZero, shortValue, valueOfLog10

Methods inherited from class com.rubecula.util.Item

audit, audit, compareTo, Debug, getClassNameShort, getType, IsDebug, present, SetDebug, test, test, Wrap

Methods inherited from class java.lang.Object

equals, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.rubecula.jquantity.Mutable

isMutable, setConstant

Methods inherited from interface com.rubecula.util.Auditable

audit, audit

Field Detail

$1

public static final Rational $1

$1 is the Rational representation of the exact value 1.

$0

public static final Rational $0

$0 is the Rational representation of the exact value 0.

$10

public static final Rational $10

$10 is the Rational representation of the exact value 10.

$2

public static final Rational $2

$2 is the Rational representation of the exact value 2.

$1_2

public static final Rational $1_2

$1_2 is the Rational representation of the exact value 1/2.

$Infinity

public static final Rational $Infinity

$Infinity is the Rational representation of the (exact) value of infinity, i.e. 1/0.

$E

public static final Rational $E

Value of E as a Rational. Note that if you want an exact value, then use Value.$E

$Pi

public static final Rational $Pi

Value of Pi as a Rational. Note that if you want an exact value, then use Value.PI

_Numerator

protected BaseNumber _Numerator

_Numerator is the numerator of the rational quantity defined by this. In practice, the numerator is always an Integral number, by virtue of the available constructors and mutators.

_Denominator

protected BaseNumber _Denominator

_Denominator is the denominator of the rational quantity defined by this. In practice, the denominator is always an Integral number, by virtue of the available constructors and mutators.

_Estimate

protected double _Estimate

_Estimate is the best estimate of the value (STRICTLY for debugging purposes only).

$3

public static final Rational $3

$6

static final Rational $6

$12

static final Rational $12

$NaN

static final Rational $NaN

$_Pi_2

static final Rational $_Pi_2

$_Pi_4

static final Rational $_Pi_4

$_Log10_E

public static final Rational $_Log10_E

$S_Rt2

static final java.lang.String $S_Rt2

1.414213562373095048801688724209698078569671875377

See Also:: Constant Field Values

$S_Rt3

static final java.lang.String $S_Rt3

1.732050807568877293527446341505872366942805253810

See Also:: Constant Field Values

$S_Rt5

static final java.lang.String $S_Rt5

2.2360679774997896964091736687312762354406183596

See Also:: Constant Field Values

$Rt2

static final Rational $Rt2

InitialValueOf($S_Rt2).

$Rt3

static final Rational $Rt3

InitialValueOf($S_Rt3).

$Rt5

static final Rational $Rt5

InitialValueOf($S_Rt5).

$_Tan15Deg

static final Rational $_Tan15Deg

2 - $Rt3.

$_Tan22_5Deg

static final Rational $_Tan22_5Deg

1 / (1 + Rt2).

$_Tan30Deg

static final Rational $_Tan30Deg

1/$Rt3.

$_c

static final Rational $_c

By definition, the velocity of light (in meter/second). Value: Manifest.$_c This value is exact. See c,c0.

$_g

static final Rational $_g

By definition, the standard (mean) gravity at the Earth's surface: 9.80665.

$_degR

public static final Rational $_degR

Degrees Rankine/Kelvin conversion: 5/9.

$_degF

static final Rational $_degF

Degrees Fahrenheit/Celsius offset: 32.

MAX_RATIO_BITS

private static final int MAX_RATIO_BITS

See Also:: Constant Field Values

PRESENTATION_TOLERANCE

private static final double PRESENTATION_TOLERANCE

See Also:: Constant Field Values

Constructor Detail

Rational

public Rational()

Empty constructor to make an undefined Rational object. The purpose of this is for an instance to be created on which to call the class method Parse(Presentation).

Rational

public Rational(java.lang.String string)
         throws PresentationException

Secondary constructor to create a Rational from a String.
Parameters:: string - the String from which to create a Rationa.
Throws:: PresentationException - if the string cannot be parsed as a Rational object.

Rational

public Rational(Integral numerator,
                Integral denominator,
                java.lang.String identifier)

Constructs an identified Rational representing the ratio of numerator divided by denominator.
Parameters:: numerator - the numerator (top) of the ratio.; denominator - the denominator (bottom) of the ratio.; identifier - the identifier to be used to identify this object.

Rational

public Rational(Integral numerator,
                Integral denominator)

Constructs a non-explicitly identified, normalized Rational representing the ratio of numerator divided by denominator.
Parameters:: numerator - Integral which is the numerator (top) of the ratio; denominator - Integral which is the denominator (bottom) of the ratio

Rational

public Rational(Integral numerator,
                java.lang.String identifier)

Constructs an identified Rational representing the ratio of numerator divided by denominator, with optional normalization.
Parameters:: numerator - the numerator (top) of the ratio; identifier - the identifier to be used to identify this object.

Rational

public Rational(Integral value)

Constructs a non-explicitly identified Rational representing the ratio of value divided by unity.
Parameters:: value - the numerator (top) of the ratio.

Rational

public Rational(long numerator,
                long denominator)

Convenience constructor for two longs.
Parameters:: numerator - the top of the ratio; denominator - the bottom of the ratio

Rational

protected Rational(java.math.BigDecimal x,
                   java.lang.String identifier)

Factory method to create a Rational from a BigDecimal value and an identifier. Constructs a new instance of Rational with same value as x and with bounds determined from the scale of x and uniform error distribution.
Parameters:: x - a BigDecimal number which is to be widened into a Rationa.; identifier - the identifier for the new instance.

Rational

protected Rational(Integral numerator,
                   Integral denominator,
                   boolean normalize,
                   java.lang.String identifier)

Constructs an identified Rational representing the ratio of numerator divided by denominator, with optional normalization. This is protected because non-extenders should not be able to determine if the number be normalized.
Parameters:: numerator - the numerator (top) of the ratio, which must be an instance of either Manifest or WholeNumber.; denominator - the denominator (bottom) of the ratio, which must be an instance of either Manifest or WholeNumber.; normalize - normally true (only set to false if you really know what you're doing).; identifier - the identifier to be used to identify this object (or null).
Throws:: Rational.RationalException - if either numerator or denominator is not an instance of either Manifest or WholeNumber.

Rational

protected Rational(Integral numerator,
                   Integral denominator,
                   boolean normalize)

Constructs a non-explicitly identified Rational representing the ratio of numerator divided by denominator, with optional normalization.
Parameters:: numerator - the numerator (top) of the ratio.; denominator - the denominator (bottom) of the ratio.; normalize - normally true (only set to false if you really know what you're doing)

Rational

Rational(java.math.BigDecimal x)

Rational

protected Rational(Rational source)

Constructor to make a copy of a Rational object.
This is an alternative to the clone() method and private to the class and its subclasses. This method behaves similarly to clone with regard to the referenced objects.
Parameters:: source - the object to copy. // TODO is their any real reason for having this constructor? // TODO should this simply call clone()? Surely that would be more consistent?

Method Detail

Parse

public static Rational Parse(NumberPresentation presentation,
                             java.lang.String identifier)
                      throws PresentationException

Translates the NumberPresentation representation into a new Rational. The result is not a constant.

Parameters:: presentation - NumberPresentation.; identifier - A string with which to identify this Rational.
Returns:: a new mutable instance of Rational, widened from the presentation.
Throws:: PresentationException - if the presentation cannot be parsed as a Rational object.

valueOf

public static Rational valueOf(BaseNumber number)

Factory method to create a Rational from a BaseNumber or, if number is Rational, then to make a copy. The result is marked as a constant.

Parameters:: number - the value to be widened into a Rational.
Returns:: a new immutable instance of Rational, widened from number.

valueOf

public static BaseNumber valueOf(java.lang.String string,
                                 java.lang.String id)
                          throws PresentationException

Convenience factory method to create a new Rational instance from a value string and an explicit identifier.

Parameters:: string - a representation of a NumberPresentation.; id - Identifier for new Rational.
Returns:: a new mutable instance of Rational.
Throws:: PresentationException - if the string cannot be parsed as a Rational object.
See Also:: NumberPresentation.NumberPresentation(String), Parse(NumberPresentation, String)

valueOf

public static BaseNumber valueOf(java.lang.String string)
                          throws PresentationException

Convenience factory method to create a new Rational instance from a value string and an implicit identifier (the value string itself).

Parameters:: string - a representation of a NumberPresentation.
Returns:: a new mutable instance of Rational.
Throws:: PresentationException - if the string cannot be parsed as a Rational object.
See Also:: valueOf(String,String)

makePresentableInstance

public Presentable makePresentableInstance(Presentation presentation)
                                    throws PresentationException

Instance method to convert a Presentation into a Presentable. Ideally, this would be a class method, but such a method cannot be defined in an interface. Nor can it be defined in an abstract class with the intention of overriding it in a subclass. Polymorphism just doesn't work that way.
Therefore, the present value (as in fields) of the instance is essentially ignored - only the methods are important.

Specified by:: makePresentableInstance in interface Presentable

Parameters:: presentation - of a number to be converted into a Presentable number.
Returns:: a number in the form of a Presentable.
Throws:: PresentationException - if presentation cannot be parsed appropriately.

Parse

public static Presentable Parse(Presentation presentation)
                         throws PresentationException

Create a Rational from a Presentation and return it as a Presentable.

Parameters:: presentation - A presentation which should be parsed to form a Presentable.
Returns:: A Rational which corresponds to the presentation.
Throws:: PresentationException - if the presentation cannot be parsed as a Presentable object.

clone

public java.lang.Object clone()

Creates and returns a deep copy of this object.

Overrides:: clone in class MutableNumber

Returns:: a clone of this instance.
Throws:: Rational.RationalException - : Rational not Cloneable (should be impossible)
See Also:: Cloneable

getBoundAbs

public double getBoundAbs()

Method to get the absolute bound of non-fuzzy value.

Overrides:: getBoundAbs in class BaseNumber

Returns:: the absolute bound of this. // TODO if infinite then bound should be zero (infinity is an exact number).
See Also:: BaseNumber.getBound(), BaseNumber.doubleValue(), Math.abs(double)

getBound

public double getBound()

Method to get the relative bound of this Rational.

Specified by:: getBound in interface Fuzzy
Overrides:: getBound in class BaseNumber

Returns:: rel. bound of numerator less rel. bound of denominator.

getModel

public int getModel()

Method to get the error distribution model of this non-fuzzy object.

Specified by:: getModel in interface Fuzzy
Overrides:: getModel in class BaseNumber

Returns:: Fuzzy.$DistNone int: non-fuzzy distribution.

isExact

public boolean isExact()

Method to determine if the quantity represented is non-fuzzy;

Specified by:: isExact in interface Fuzzy
Overrides:: isExact in class BaseNumber

Returns:: true boolean: always

intValue

public int intValue()

Method to yield the equivalent integer value for this object. Objects which are infinite or non=integral throw exceptions.

Specified by:: intValue in class BaseNumber

Returns:: int : the integer value of this.

longValue

public long longValue()

Method to yield the equivalent integer value for this object. Objects which are infinite or non-integral throw exceptions.

Specified by:: longValue in class BaseNumber

Returns:: int : the integer value of this.

floatValue

public float floatValue()

Returns the value of the specified number as a float. This may involve rounding.

Specified by:: floatValue in class BaseNumber

Returns:: the numeric value represented by this object after conversion to type float.

doubleValue

public double doubleValue()

Returns the value of the specified number as a double. This may involve rounding.

Specified by:: doubleValue in class BaseNumber

Returns:: the numeric value represented by this object after conversion to type double.

signum

public int signum()

Method to find the sign of the magnitude of this arithmetical object.

Specified by:: signum in interface Arithmetical

Returns:: 0 if value is 0; 1 if value is positive; -1 if value is negative.

isInteger

public boolean isInteger()

Method determines if it is safe and appropriate to convert this arithmetical object into BigInteger.

Specified by:: isInteger in interface Arithmetical

Returns:: true if isExact() and denominator is equal to 1.

isUnity

public boolean isUnity()

Method to determine if this arithmetical object has the exact value of 1.

Specified by:: isUnity in interface Arithmetical

Returns:: true if value is 1 and isExact().

isInfinite

public boolean isInfinite()

Method to determine if an arithmetical object is infinite.

Specified by:: isInfinite in interface Arithmetical

Returns:: true if object is infinite in value.