## net.sf.saxon.value
Class DecimalValue

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

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

public final class DecimalValue
extends NumericValue

A decimal value

See Also:
  Serialized Form

Field Summary

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

Constructor Summary
`DecimalValue(java.math.BigDecimal value)` Constructor supplying a BigDecimal
`DecimalValue(java.lang.CharSequence in)` Constructor supplying a String
`DecimalValue(double in)` Constructor supplying a double
`DecimalValue(long in)` Constructor supplying a long integer

Method Summary
`NumericValue` `arithmetic(int operator, NumericValue other, XPathContext context)` Evaluate a binary arithmetic operator.
`NumericValue` `ceiling()` Implement the XPath ceiling() function
`int` `compareTo(java.lang.Object other)` Compare the value to another numeric value
`AtomicValue` `convert(int requiredType, XPathContext context)` Convert to target data type
`java.lang.Object` `convertToJava(java.lang.Class target, Configuration config, XPathContext context)` Convert to Java object (for passing to external functions)
`boolean` `effectiveBooleanValue(XPathContext context)` Get the effective boolean value of the value
`NumericValue` `floor()` Implement the XPath floor() function
`ItemType` `getItemType()` Determine the data type of the expression
`java.lang.String` `getStringValue()` Get the value as a String
`java.math.BigDecimal` `getValue()` Get the value
`int` `hashCode()` Get the hashCode.
`boolean` `isWholeNumber()` Determine whether the value is a whole number, that is, whether it compares equal to some integer
`NumericValue` `negate()` Negate the value
`NumericValue` `round()` Implement the XPath round() function
`NumericValue` `roundToHalfEven(int scale)` Implement the XPath round-to-half-even() function

Methods inherited from class net.sf.saxon.value.NumericValue
`equals, getDoubleValue, isInteger, isNaN, longValue, parseNumber, promote, toString`

Methods inherited from class net.sf.saxon.value.AtomicValue
`convert, display, evaluateAsString, evaluateItem, getCardinality, getComponent, getImplementationMethod, getPrimitiveValue, 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`

Constructor Detail

### DecimalValue

    public DecimalValue(java.math.BigDecimal value)

  Constructor supplying a BigDecimal

Parameters:
  `value` - the value of the DecimalValue

### DecimalValue

    public DecimalValue(java.lang.CharSequence in)
                 throws XPathException

  Constructor supplying a String

Parameters:
  `in` - the value of the DecimalValue

### DecimalValue

    public DecimalValue(double in)
                 throws XPathException

  Constructor supplying a double

Parameters:
  `in` - the value of the DecimalValue

### DecimalValue

    public DecimalValue(long in)

  Constructor supplying a long integer

Parameters:
  `in` - the value of the DecimalValue

Method Detail

### getValue

    public java.math.BigDecimal getValue()

  Get the value

### hashCode

    public int hashCode()

  Get the hashCode. This must conform to the rules for other NumericValue hashcodes

  Specified by:
    `hashCode` in class `NumericValue`
  Returns:
    the hash code of the numeric value
  See Also:
    `NumericValue.hashCode()`

### effectiveBooleanValue

    public boolean effectiveBooleanValue(XPathContext context)

  Description copied from class: `AtomicValue`
  Get the effective boolean value of the value

  Specified by:
    `effectiveBooleanValue` in interface `Expression`
  Overrides:
    `effectiveBooleanValue` in class `AtomicValue`
  Parameters:
    `context` - the evaluation context (not used in this implementation)
  Returns:
    true, unless the value is boolean false, numeric zero, or zero-length string

### convert

    public AtomicValue convert(int requiredType,
                               XPathContext context)
                        throws XPathException

  Convert to target data type

  Specified by:
    `convert` in class `AtomicValue`
  Parameters:
    `requiredType` - type code of the required atomic type
    `context` - the evaluation context. Used primarily for error reporting, since nearly all type conversions are context-independent. The value may be null if the context is not known.
  Returns:
    the result of the conversion, if conversion was possible. This will always be an instance of the class corresponding to the type of value requested
  Throws:
    `XPathException` - if conversion is not allowed for this required type, or if the particular value cannot be converted

### getStringValue

    public java.lang.String getStringValue()

  Get the value as a String

  Specified by:
    `getStringValue` in interface `Item`
  Specified by:
    `getStringValue` in class `AtomicValue`
  Returns:
    a String representation of the value

### getItemType

    public ItemType getItemType()

  Determine the data type of the expression

  Returns:
    Type.DECIMAL

### negate

    public NumericValue negate()

  Negate the value

  Specified by:
    `negate` in class `NumericValue`
  Returns:
    a value, of the same type as the original, with its sign inverted

### floor

    public NumericValue floor()

  Implement the XPath floor() function

  Specified by:
    `floor` in class `NumericValue`
  Returns:
    a value, of the same type as that supplied, rounded towards minus infinity

### ceiling

    public NumericValue ceiling()

  Implement the XPath ceiling() function

  Specified by:
    `ceiling` in class `NumericValue`
  Returns:
    a value, of the same type as that supplied, rounded towards plus infinity

### round

    public NumericValue round()

  Implement the XPath round() function

  Specified by:
    `round` in class `NumericValue`
  Returns:
    a value, of the same type as that supplied, rounded towards the nearest whole number (0.5 rounded up)

### roundToHalfEven

    public NumericValue roundToHalfEven(int scale)

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

  Specified by:
    `roundToHalfEven` in class `NumericValue`
  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

### isWholeNumber

    public boolean isWholeNumber()

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

  Specified by:
    `isWholeNumber` in class `NumericValue`
  Returns:
    true if the value is a whole number

### arithmetic

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

  Evaluate a binary arithmetic operator.

  Specified by:
    `arithmetic` in class `NumericValue`
  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`

### compareTo

    public int compareTo(java.lang.Object other)

  Compare the value to another numeric value

  Specified by:
    `compareTo` in interface `java.lang.Comparable`
  Overrides:
    `compareTo` in class `NumericValue`
  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.

### convertToJava

    public java.lang.Object convertToJava(java.lang.Class target,
                                          Configuration config,
                                          XPathContext context)
                                   throws XPathException

  Convert to Java object (for passing to external functions)

  Overrides:
    `convertToJava` in class `AtomicValue`
  Parameters:
    `target` - The class required by the external function
    `config` - The configuration (needed for access to schema information)
  Returns:
    an object of the target class
    `XPathException`