## net.sf.saxon.value
Class NumericValue

    java.lang.Object
      |
      +--net.sf.saxon.value.Value
            |
            +--net.sf.saxon.value.AtomicValue
                  |
                  +--net.sf.saxon.value.NumericValue

All Implemented Interfaces:
  java.lang.Comparable, Expression, Item, java.io.Serializable

Direct Known Subclasses:
  BigIntegerValue, DecimalValue, DoubleValue, FloatValue, IntegerValue

public abstract class NumericValue
extends AtomicValue
implements java.lang.Comparable

NumericValue is an abstract superclass for IntegerValue, DecimalValue, FloatValue, and DoubleValue

See Also:
  Serialized Form

Field Summary

Fields inherited from interface net.sf.saxon.expr.Expression
`EVALUATE_METHOD, ITERATE_METHOD, PROCESS_METHOD`

Constructor Summary
`NumericValue()`

Method Summary
`abstract NumericValue` `arithmetic(int operator, NumericValue other, XPathContext context)` Perform a binary arithmetic operation
`abstract NumericValue` `ceiling()` Implement the XPath ceiling() function
`int` `compareTo(java.lang.Object other)` Compare the value to another numeric value
`boolean` `equals(java.lang.Object other)` The equals() function compares numeric equality among integers, decimals, floats, doubles, and their subtypes
`abstract NumericValue` `floor()` Implement the XPath floor() function
`double` `getDoubleValue()` Get the numeric value as a double
`abstract int` `hashCode()` hashCode() must be the same for two values that are equal.
`static boolean` `isInteger(AtomicValue value)` Test whether the value is an integer (an instance of a subtype of xs:integer)
`boolean` `isNaN()` Test whether the value is the double/float value NaN
`abstract boolean` `isWholeNumber()` Determine whether the value is a whole number, that is, whether it compares equal to some integer
`long` `longValue()` Return the numeric value as a Java long.
`abstract NumericValue` `negate()` Change the sign of the number
`static NumericValue` `parseNumber(java.lang.String in)` Get a numeric value by parsing a string; the type of numeric value depends on the lexical form of the string, following the rules for XPath numeric literals.
`static ItemType` `promote(ItemType v1, ItemType v2)` Identify lowest common supertype of two numeric values for promotion purposes
`abstract NumericValue` `round()` Implement the XPath round() function
`abstract NumericValue` `roundToHalfEven(int scale)` Implement the XPath 2.0 round-to-half-even() function
`java.lang.String` `toString()` Produce a string representation of the value

Methods inherited from class net.sf.saxon.value.AtomicValue
`convert, convert, convertToJava, display, effectiveBooleanValue, evaluateAsString, evaluateItem, getCardinality, getComponent, getImplementationMethod, getPrimitiveValue, getStringValue, getTypedValue, iterate, process`

Methods inherited from class net.sf.saxon.value.Value
`analyze, asItem, asValue, collapseWhitespace, convertJavaObjectToXPath, getDependencies, getParentExpression, getSpecialProperties, inverse, iterateSubExpressions, normalizeWhitespace, promote, simplify, stringToNumber, trimWhitespace`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Methods inherited from interface net.sf.saxon.expr.Expression
`getItemType`

Constructor Detail

### NumericValue

    public NumericValue()

Method Detail

### parseNumber

    public static NumericValue parseNumber(java.lang.String in)

  Get a numeric value by parsing a string; the type of numeric value depends on the lexical form of the string, following the rules for XPath numeric literals.

  Parameters:
    `in` - the input string
  Returns:
    a NumericValue representing the value of the string. Returns Double.NaN if the value cannot be parsed as a string.

### getDoubleValue

    public double getDoubleValue()

  Get the numeric value as a double

  Returns:
    A double representing this numeric value; NaN if it cannot be converted

### isNaN

    public boolean isNaN()

  Test whether the value is the double/float value NaN

### isInteger

    public static boolean isInteger(AtomicValue value)

  Test whether the value is an integer (an instance of a subtype of xs:integer)

### longValue

    public long longValue()
                   throws XPathException

  Return the numeric value as a Java long.

  Returns:
    the numeric value as a Java long. This performs truncation towards zero.
  Throws:
    `XPathException` - if the value cannot be converted

### negate

    public abstract NumericValue negate()
                                 throws XPathException

  Change the sign of the number

  Returns:
    a value, of the same type as the original, with its sign inverted
  Throws:
    `XPathException` - if the conversion is not possible

### floor

    public abstract NumericValue floor()

  Implement the XPath floor() function

  Returns:
    a value, of the same type as that supplied, rounded towards minus infinity

### ceiling

    public abstract NumericValue ceiling()

  Implement the XPath ceiling() function

  Returns:
    a value, of the same type as that supplied, rounded towards plus infinity

### round

    public abstract NumericValue round()

  Implement the XPath round() function

  Returns:
    a value, of the same type as that supplied, rounded towards the nearest whole number (0.5 rounded up)

### roundToHalfEven

    public abstract NumericValue roundToHalfEven(int scale)

  Implement the XPath 2.0 round-to-half-even() function

  Parameters:
    `scale` - the decimal position for rounding: e.g. 2 rounds to a multiple of 0.01, while -2 rounds to a multiple of 100
  Returns:
    a value, of the same type as the original, rounded towards the nearest multiple of 10**(-scale), with rounding towards the nearest even number if two values are equally near

### arithmetic

    public abstract NumericValue arithmetic(int operator,
                                            NumericValue other,
                                            XPathContext context)
                                     throws XPathException

  Perform a binary arithmetic operation

  Parameters:
    `operator` - the binary arithmetic operation to be performed. Uses the constants defined in the Tokenizer class
    `other` - the other operand
  Returns:
    the result of the arithmetic operation
  Throws:
    `XPathException` - if an arithmetic error occurs
  See Also:
    `Tokenizer`

### isWholeNumber

    public abstract boolean isWholeNumber()

  Determine whether the value is a whole number, that is, whether it compares equal to some integer

  Returns:
    true if the value is a whole number

### compareTo

    public int compareTo(java.lang.Object other)

  Compare the value to another numeric value

  Specified by:
    `compareTo` in interface `java.lang.Comparable`
  Parameters:
    `other` - The other numeric value
  Returns:
    -1 if this one is the lower, 0 if they are numerically equal, +1 if this one is the higher.
  Throws:
    `java.lang.ClassCastException` - if the other value is not a NumericValue (the parameter is declared as Object to satisfy the Comparable interface)

### equals

    public final boolean equals(java.lang.Object other)

  The equals() function compares numeric equality among integers, decimals, floats, doubles, and their subtypes

  Overrides:
    `equals` in class `java.lang.Object`
  Parameters:
    `other` - the value to be compared with this one
  Returns:
    true if the two values are numerically equal

### promote

    public static ItemType promote(ItemType v1,
                                   ItemType v2)

  Identify lowest common supertype of two numeric values for promotion purposes

  Parameters:
    `v1` - the item type of the first operand
    `v2` - the item type of the second operand
  Returns:
    the item type that should be used for arithmetic between operands of the two specified item types

### hashCode

    public abstract int hashCode()

  hashCode() must be the same for two values that are equal. One way to ensure this is to convert the value to a double, and take the hashCode of the double. But this is expensive in the common case where we are comparing integers. So we adopt the rule: for values that are in the range of a Java Integer, we use the int value as the hashcode. For values outside that range, we convert to a double and take the hashCode of the double. This method needs to have a compatible implementation in each subclass.

  Overrides:
    `hashCode` in class `java.lang.Object`
  Returns:
    the hash code of the numeric value

### toString

    public java.lang.String toString()

  Produce a string representation of the value

  Overrides:
    `toString` in class `AtomicValue`
  Returns:
    The result of casting the number to a string