Overview | Package | Class | Deprecated | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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:
  Serializable, Comparable, SequenceIterable, Item, ValueRepresentation

Direct Known Subclasses:
  DecimalValue, DoubleValue, FloatValue, IntegerValue

    public abstract class NumericValue

extends AtomicValue
implements 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.Value
`EMPTY_CLASS_ARRAY, INDETERMINATE_ORDERING`

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

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
`abstract int` | `compareTo(long other)` Compare the value to a long
`int` | `compareTo(Object other)` Compare the value to another numeric value
`boolean` | `equals(Object other)` The equals() function compares numeric equality among integers, decimals, floats, doubles, and their subtypes
`abstract NumericValue` | `floor()` Implement the XPath floor() function
`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
`Comparable` | `getXPathComparable()` 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 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(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
`String` | `toString()` Produce a string representation of the value

Methods inherited from class net.sf.saxon.value.AtomicValue
`checkPermittedContents, convert, convert, convertPrimitive, copy, effectiveBooleanValue, getCardinality, getComponent, getItemType, getLength, getPrimitiveType, getStringValue, getStringValueCS, getTypedValue, getTypeLabel, hasBuiltInType, isMultiValued, itemAt, iterate, process, setTypeLabel`

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

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

Constructor Detail

### NumericValue

    public NumericValue()

Method Detail

### parseNumber

    public static NumericValue parseNumber(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 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

### 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()

  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

### 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 Token class, for example `Token.PLUS`, `Token.MINUS`
    `other` - the second 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

### getXPathComparable

    public Comparable getXPathComparable()

  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.

  Overrides:
    `getXPathComparable` in class `AtomicValue`

### compareTo

    public int compareTo(Object other)

  Compare the value to another numeric value

  Specified by:
    `compareTo` in interface `Comparable`
  Overrides:
    `compareTo` in class `Value`
  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:
    `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(Object other)

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

  Overrides:
    `equals` in class `Value`
  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` -
  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 `Value`
  Returns:
    the hash code of the numeric value

### toString

    public String toString()

  Produce a string representation of the value

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

Overview | Package | Class | Deprecated | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright (C) Michael H. Kay. All rights reserved.