NumericValue

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

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable, PullEvent, SequenceIterable, GroundedValue, Item, ValueRepresentation, ConversionResult

Direct Known Subclasses:

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 class net.sf.saxon.value.AtomicValue
  typeLabel
- Fields inherited from class net.sf.saxon.value.Value
  EMPTY_CLASS_ARRAY, INDETERMINATE_ORDERING
- Fields inherited from interface net.sf.saxon.om.ValueRepresentation
  EMPTY_VALUE_ARRAY

Constructor Summary

Constructors
Constructor Description

NumericValue()

Constructors
Constructor	Description
`NumericValue()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`abstract NumericValue`	`ceiling()`	Implement the XPath ceiling() function
`abstract int`	`compareTo(long other)`	Compare the value to a long
`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
`java.math.BigDecimal`	`getDecimalValue()`	Get the numeric value converted to a decimal
`double`	`getDoubleValue()`	Get the numeric value as a double
`float`	`getFloatValue()`	Get the numeric value converted to a float
`java.lang.Object`	`getXPathComparable(boolean ordered, StringCollator collator, XPathContext context)`	Get a Comparable value that implements the XPath ordering comparison semantics for this value.
`abstract int`	`hashCode()`	hashCode() must be the same for two values that are equal.
`static boolean`	`isInteger(AtomicValue value)`	Test whether a value is an integer (an instance of a subtype of xs:integer)
`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, TypeHierarchy typeHierarchy)`	Identify lowest common supertype of two numeric values for promotion purposes
`abstract NumericValue`	`round()`	Implement the XPath round() function
`abstract NumericValue`	`roundHalfToEven(int scale)`	Implement the XPath 2.0 round-half-to-even() function
`abstract double`	`signum()`	Determine whether the value is negative, zero, or positive
`java.lang.String`	`toString()`	Produce a string representation of the value

Methods inherited from class net.sf.saxon.value.AtomicValue
asAtomic, checkPermittedContents, convert, convert, convertPrimitive, copyAsSubType, effectiveBooleanValue, getCardinality, getComponent, getItemType, getLength, getPrimitiveType, getSchemaComparable, getStringValue, getStringValueCS, getTypedValue, getTypeLabel, isNaN, itemAt, iterate, process, setTypeLabel, subsequence

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

Methods inherited from class net.sf.saxon.value.Value
asItem, asItem, asIterator, asValue, convertToJava, fromItem, getCanonicalLexicalRepresentation, getIterator, iterate, makeQNameValue, reduce, stringToNumber

- 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
  - getFloatValue
```
public float getFloatValue()
```
    Get the numeric value converted to a float
    
    Returns:
    
    a float representing this numeric value; NaN if it cannot be converted
  - getDecimalValue
```
public java.math.BigDecimal getDecimalValue()
                                     throws XPathException
```
    Get the numeric value converted to a decimal
    
    Returns:
    
    a decimal representing this numeric value;
    
    Throws:
    
    XPathException - if the value cannot be converted, for example if it is NaN or infinite
  - isInteger
```
public static boolean isInteger(AtomicValue value)
```
    Test whether a value is an integer (an instance of a subtype of xs:integer)
    
    Parameters:
    
    value - the value being tested
    
    Returns:
    
    true if the value is an instance of xs:integer or a type derived therefrom
  - 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()
```
    Change the sign of the number
    
    Returns:
    
    a value, of the same type as the original, with its sign inverted
  - 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)
  - roundHalfToEven
```
public abstract NumericValue roundHalfToEven(int scale)
```
    Implement the XPath 2.0 round-half-to-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
  - signum
```
public abstract double signum()
```
    Determine whether the value is negative, zero, or positive
    
    Returns:
    
    -1 if negative, 0 if zero (including negative zero), +1 if positive, NaN if NaN
  - 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
  - getXPathComparable
```
public java.lang.Object getXPathComparable(boolean ordered,
                                           StringCollator collator,
                                           XPathContext context)
```
    Get a Comparable value that implements the XPath ordering comparison semantics for this value. Returns null if the value is not comparable according to XPath rules. The default implementation returns null. This is overridden for types that allow ordered comparisons in XPath: numeric, boolean, string, date, time, dateTime, yearMonthDuration, dayTimeDuration, and anyURI.
    
    Specified by:
    
    getXPathComparable in class AtomicValue
    
    Parameters:
    
    ordered -
    
    collator -
    
    context -
    
    Returns:
    
    an Object whose equals() and hashCode() methods implement the XPath comparison semantics with respect to this atomic value. If ordered is specified, the result will either be null if no ordering is defined, or will be a Comparable
  - 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, or if either value is NaN. Where NaN values are involved, they should be handled by the caller before invoking this method.
    
    Throws:
    
    java.lang.ClassCastException - if the other value is not a NumericValue (the parameter is declared as Object to satisfy the Comparable interface)
  - compareTo
```
public abstract int compareTo(long other)
```
    Compare the value to a long
    
    Parameters:
    
    other - the value to be compared with
    
    Returns:
    
    -1 if this is less, 0 if this is equal, +1 if this is greater or if this is NaN
  - equals
```
public final boolean equals(java.lang.Object other)
```
    The equals() function compares numeric equality among integers, decimals, floats, doubles, and their subtypes
    
    Specified by:
    
    equals in class AtomicValue
    
    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,
                               TypeHierarchy typeHierarchy)
```
    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
    
    typeHierarchy - the type hierarchy cache
    
    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

Class NumericValue

Field Summary

Fields inherited from class net.sf.saxon.value.AtomicValue

Fields inherited from class net.sf.saxon.value.Value

Fields inherited from interface net.sf.saxon.om.ValueRepresentation

Constructor Summary

Method Summary

Methods inherited from class net.sf.saxon.value.AtomicValue

Methods inherited from class java.lang.Object

Methods inherited from class net.sf.saxon.value.Value

Constructor Detail

NumericValue

Method Detail

parseNumber

getDoubleValue

getFloatValue

getDecimalValue

isInteger

longValue

negate

floor

ceiling

round

roundHalfToEven

signum

isWholeNumber

getXPathComparable

compareTo

compareTo

equals

promote

hashCode

toString