The presentation of this document has been augmented to identify changes from the version 3.1 Recommendation published on 21 March 2017. Three kinds of changes are highlighted: new, added text, changed text, and deleted text.

# XPath and XQuery Functions and Operators 4.0

## W3C Editor's Draft 5 December 2022

This version:
https://qt4cg.org/specifications/xpath-functions-40/
https://qt4cg.org/specifications/xpath-functions-40/
Most recent Recommendation of XPath and XQuery Functions and Operators:
https://www.w3.org/TR/2017/REC-xpath-functions-31-20170321/
Editor:
Michael Kay, Saxonica <http://www.saxonica.com/>

Please check the errata for any errors or issues reported since publication.

This document is also available in these non-normative formats: Specification in XML format using HTML5 vocabulary, XML function catalog, and HTML with change markings relative to version 3.0.

## Abstract

This document defines constructor functions, operators, and functions on the datatypes defined in [XML Schema Part 2: Datatypes Second Edition] and the datatypes defined in [XQuery and XPath Data Model (XDM) 3.1]. It also defines functions and operators on nodes and node sequences as defined in the [XQuery and XPath Data Model (XDM) 3.1]. These functions and operators are defined for use in [XML Path Language (XPath) 4.0] and [XQuery 4.1: An XML Query Language] and [XSL Transformations (XSLT) Version 4.0] and other related XML standards. The signatures and summaries of functions defined in this document are available at: http://www.w3.org/2005/xpath-functions/.

A summary of changes since version 3.1 is provided at F Changes since version 3.1.

## Status of this Document

This version of the specification is work in progress. It is produced by the QT4 Working Group, officially the W3C XSLT 4.0 Extensions Community Group. Individual functions specified in the document may be at different stages of review, reflected in their History notes. Comments are invited.

## 1 Introduction

The purpose of this document is to propose functions and operators to be included in XPath 4.0, XQuery 4.0, and XSLT 4.0. Note that this proposal has no official standing at the time of publication. The exact syntax used to call these functions and operators is specified in [XML Path Language (XPath) 4.0], [XQuery 4.1: An XML Query Language] and [XSL Transformations (XSLT) Version 4.0].

This document defines three classes of functions:

• General purpose functions, available for direct use in user-written queries, stylesheets, and XPath expressions, whose arguments and results are values defined by the [XQuery and XPath Data Model (XDM) 3.1].

• Constructor functions, used for creating instances of a datatype from values of (in general) a different datatype. These functions are also available for general use; they are named after the datatype that they return, and they always take a single argument.

• Functions that specify the semantics of operators defined in [XML Path Language (XPath) 4.0] and [XQuery 4.1: An XML Query Language]. These exist for specification purposes only, and are not intended for direct calling from user-written code.

[XML Schema Part 2: Datatypes Second Edition] defines a number of primitive and derived datatypes, collectively known as built-in datatypes. This document defines functions and operations on these datatypes as well as the other types (for example, nodes and sequences of nodes) defined in Section 2.7 Schema Information DM31 of the [XQuery and XPath Data Model (XDM) 3.1]. These functions and operations are available for use in [XML Path Language (XPath) 4.0], [XQuery 4.1: An XML Query Language] and any other host language that chooses to reference them. In particular, they may be referenced in future versions of XSLT and related XML standards.

[Schema 1.1 Part 2] adds to the datatypes defined in [XML Schema Part 2: Datatypes Second Edition]. It introduces a new derived type xs:dateTimeStamp, and it incorporates as built-in types the two types xs:yearMonthDuration and xs:dayTimeDuration which were previously XDM additions to the type system. In addition, XSD 1.1 clarifies and updates many aspects of the definitions of the existing datatypes: for example, it extends the value space of xs:double to allow both positive and negative zero, and extends the lexical space to allow +INF; it modifies the value space of xs:Name to permit additional Unicode characters; it allows year zero and disallows leap seconds in xs:dateTime values; and it allows any character string to appear as the value of an xs:anyURI item. Implementations of this specification may support either XSD 1.0 or XSD 1.1 or both.

References to specific sections of some of the above documents are indicated by cross-document links in this document. Each such link consists of a pointer to a specific section followed a superscript specifying the linked document. The superscripts have the following meanings: 'XQ' [XQuery 4.1: An XML Query Language], 'XT' [XSL Transformations (XSLT) Version 4.0], 'XP' [XML Path Language (XPath) 4.0], and 'DM' [XQuery and XPath Data Model (XDM) 3.1].

### 1.1 Conformance

This recommendation contains a set of function specifications. It defines conformance at the level of individual functions. An implementation of a function conforms to a function specification in this recommendation if all the following conditions are satisfied:

• For all combinations of valid inputs to the function (both explicit arguments and implicit context dependencies), the result of the function meets the mandatory requirements of this specification.

• For all invalid inputs to the function, the implementation signals (in some way appropriate to the calling environment) that a dynamic error has occurred.

• For a sequence of calls within the same ·execution scope·, the requirements of this recommendation regarding the ·determinism· of results are satisfied (see 1.7.4 Properties of functions).

Other recommendations ("host languages") that reference this document may dictate:

• Subsets or supersets of this set of functions to be available in particular environments;

• Mechanisms for invoking functions, supplying arguments, initializing the static and dynamic context, receiving results, and handling errors;

• A concrete realization of concepts such as ·execution scope·;

• Which versions of other specifications referenced herein (for example, XML, XSD, or Unicode) are to be used.

Any behavior that is discretionary (implementation-defined or implementation-dependent) in this specification may be constrained by a host language.

Note:

Adding such constraints in a host language, however, is discouraged because it makes it difficult to re-use implementations of the function library across host languages.

This specification allows flexibility in the choice of versions of specifications on which it depends:

• It is ·implementation-defined· which version of Unicode is supported, but it is recommended that the most recent version of Unicode be used.

• It is ·implementation-defined· whether the type system is based on XML Schema 1.0 or XML Schema 1.1.

• It is ·implementation-defined· whether definitions that rely on XML (for example, the set of valid XML characters) should use the definitions in XML 1.0 or XML 1.1.

Note:

The XML Schema 1.1 recommendation introduces one new concrete datatype: xs:dateTimeStamp; it also incorporates the types xs:dayTimeDuration, xs:yearMonthDuration, and xs:anyAtomicType which were previously defined in earlier versions of [XQuery and XPath Data Model (XDM) 3.1]. Furthermore, XSD 1.1 includes the option of supporting revised definitions of types such as xs:NCName based on the rules in XML 1.1 rather than 1.0.

In this document, text labeled as an example or as a Note is provided for explanatory purposes and is not normative.

### 1.2 Namespaces and prefixes

The functions and operators defined in this document are contained in one of several namespaces (see [Namespaces in XML]) and referenced using an xs:QName.

This document uses conventional prefixes to refer to these namespaces. User-written applications can choose a different prefix to refer to the namespace, so long as it is bound to the correct URI. The host language may also define a default namespace for function calls, in which case function names in that namespace need not be prefixed at all. In many cases the default namespace will be http://www.w3.org/2005/xpath-functions, allowing a call on the fn:name function (for example) to be written as name() rather than fn:name(); in this document, however, all example function calls are explicitly prefixed.

The URIs of the namespaces and the conventional prefixes associated with them are:

• http://www.w3.org/2001/XMLSchema for constructors — associated with xs.

The section 18 Constructor functions defines constructor functions for the built-in datatypes defined in [XML Schema Part 2: Datatypes Second Edition] and in Section 2.7 Schema Information DM31 of [XQuery and XPath Data Model (XDM) 3.1]. These datatypes and the corresponding constructor functions are in the XML Schema namespace, http://www.w3.org/2001/XMLSchema, and are named in this document using the xs prefix.

• http://www.w3.org/2005/xpath-functions for functions — associated with fn.

The namespace prefix used in this document for most functions that are available to users is fn.

• http://www.w3.org/2005/xpath-functions/math for functions — associated with math.

This namespace is used for some mathematical functions. The namespace prefix used in this document for these functions is math. These functions are available to users in exactly the same way as those in the fn namespace.

• http://www.w3.org/2005/xpath-functions/map for functions — associated with map.

This namespace is used for some functions that manipulate maps (see 17.1 Functions that Operate on Maps). The namespace prefix used in this document for these functions is map. These functions are available to users in exactly the same way as those in the fn namespace.

• http://www.w3.org/2005/xpath-functions/array for functions — associated with array.

This namespace is used for some functions that manipulate maps (see 17.3 Functions that Operate on Arrays). The namespace prefix used in this document for these functions is array. These functions are available to users in exactly the same way as those in the fn namespace.

• http://www.w3.org/2005/xqt-errors — associated with err.

There are no functions in this namespace; it is used for error codes.

This document uses the prefix err to represent the namespace URI http://www.w3.org/2005/xqt-errors, which is the namespace for all XPath and XQuery error codes and messages. This namespace prefix is not predeclared and its use in this document is not normative.

• http://www.w3.org/2010/xslt-xquery-serialization — associated with output.

There are no functions in this namespace: it is used for serialization parameters, as described in [XSLT and XQuery Serialization 3.1]

• Functions defined with the op prefix are described here to underpin the definitions of the operators in [XML Path Language (XPath) 4.0], [XQuery 4.1: An XML Query Language] and [XSL Transformations (XSLT) Version 4.0]. These functions are not available directly to users, and there is no requirement that implementations should actually provide these functions. For this reason, no namespace is associated with the op prefix. For example, multiplication is generally associated with the * operator, but it is described as a function in this document:

 op:numeric-multiply( $arg1 as xs:numeric, $arg2 as xs:numeric ) as xs:numeric

Note:

The above namespace URIs are not expected to change from one version of this document to another. The contents of these namespaces may be extended to allow additional functions (and errors, and serialization parameters) to be defined.

A function is uniquely defined by its name and arity (number of arguments); it is therefore not possible to have two different functions that have the same name and arity, but different types in their signature. That is, function overloading in this sense of the term is not permitted. Consequently, functions such as fn:string which accept arguments of many different types have a signature that defines a very general argument type, in this case item()? which accepts any single item; supplying an inappropriate item (such as a function item) causes a dynamic error.

Some functions on numeric types include the type xs:numeric in their signature as an argument or result type. In this version of the specification, xs:numeric has been redefined as a built-in union type representing the union of xs:decimal, xs:float, xs:double (and thus automatically accepting types derived from these, including xs:integer).

Operators such as "+" may be overloaded: they map to different underlying functions depending on the dynamic types of the supplied operands.

It is possible for two functions to have the same name provided they have different arity (number of arguments). For the functions defined in this specification, where two functions have the same name and different arity, they also have closely related behavior, so they are defined in the same section of this document.

### 1.4 Function signatures and descriptions

Each function (or group of functions having the same name) is defined in this specification using a standard proforma.

The function name is a QName as defined in [XML Schema Part 2: Datatypes Second Edition] and must adhere to its syntactic conventions. Following the precedent set by [XML Path Language (XPath) Version 1.0], function names are generally composed of English words separated by hyphens ("-"). Abbreviations are used only where there is a strong precedent in other programming languages (as with math:sin and math:cos for sine and cosine). If a function name contains a [XML Schema Part 2: Datatypes Second Edition] datatype name, it may have intercapitalized spelling and is used in the function name as such. An example is fn:timezone-from-dateTime.

The first section in the proforma is a short summary of what the function does. This is intended to be informative rather than normative.

Each function is then defined by specifying its signature, which defines the types of the parameters and of the result value.

Each function's signature is presented in a form like this:

 fn:function-name( $parameter-name as parameter-type, $... as  ) as return-type

In this notation, function-name, in bold-face, is the name of the function whose signature is being specified. If the function takes no parameters, then the name is followed by an empty parameter list: "()"; otherwise, the name is followed by a parenthesized list of parameter declarations, in which each declaration specifies the static type of the parameter, in italics, and a descriptive, but non-normative, name. If there are two or more parameter declarations, they are separated by a comma. The return-type, also in italics, specifies the static type of the value returned by the function. The dynamic type of the value returned by the function is the same as its static type or derived from the static type. All parameter types and return types are specified using the SequenceType notation defined in Section 2.5.4 SequenceType Syntax XP31.

One function, fn:concat, has a variable number of arguments (two or more). More strictly, there is an infinite set of functions having the name fn:concat, with arity ranging from 2 to infinity. For this special case, a single function signature is given, with an ellipsis indicating an indefinite number of arguments.

The next section in the proforma defines the semantics of the function as a set of rules. The order in which the rules appear is significant; they are to be applied in the order in which they are written. Error conditions, however, are generally listed in a separate section that follows the main rules, and take precedence over non-error rules except where otherwise stated. The principles outlined in Section 2.3.4 Errors and Optimization XP31 apply by default: to paraphrase, if the result of the function can be determined without evaluating all its arguments, then it is not necessary to evaluate the remaining arguments merely in order to determine whether any error conditions apply.

Where the proforma includes sections headed Notes or Examples, these are non-normative.

Rules for passing parameters to operators are described in the relevant sections of [XQuery 4.1: An XML Query Language] and [XML Path Language (XPath) 4.0]. For example, the rules for passing parameters to arithmetic operators are described in Section 3.5 Arithmetic Expressions XP31. Specifically, rules for parameters of type xs:untypedAtomic and the empty sequence are specified in this section.

As is customary, the parameter type name indicates that the function or operator accepts arguments of that type, or types derived from it, in that position. This is called subtype substitution (See Section 2.5.5 SequenceType Matching XP31). In addition, numeric type instances and instances of type xs:anyURI can be promoted to produce an argument of the required type. (See Section B.1 Type Promotion XP31).

1. Subtype Substitution: A derived type may substitute for its base type. In particular, xs:integer may be used where xs:decimal is expected.

2. Numeric Type Promotion: xs:decimal may be promoted to xs:float or xs:double. Promotion to xs:double should be done directly, not via xs:float, to avoid loss of precision.

3. anyURI Type Promotion: A value of type xs:anyURI can be promoted to the type xs:string.

Some functions accept a single value or the empty sequence as an argument and some may return a single value or the empty sequence. This is indicated in the function signature by following the parameter or return type name with a question mark: "?", indicating that either a single value or the empty sequence must appear. See below.

 fn:function-name( $parameter-name as parameter-type ) as return-type? Note that this function signature is different from a signature in which the parameter is omitted. See, for example, the two signatures for fn:string. In the first signature, the parameter is omitted and the argument defaults to the context item, referred to as .. In the second signature, the argument must be present but may be the empty sequence, written as (). Some functions accept a sequence of zero or more values as an argument. This is indicated by following the name of the type of the items in the sequence with *. The sequence may contain zero or more items of the named type. For example, the function below accepts a sequence of xs:double and returns a xs:double or the empty sequence.  fn:median( $arg as xs:double* ) as xs:double?

In XPath 4.0, the arguments in a function call can be supplied by keyword as an alternative to supplying them positionally. For example the call resolve-uri(@href, static-base-uri()) can now be written resolve-uri(base: static-base-uri(), relative: @href). The order in which arguments are supplied can therefore differ from the order in which they are declared. The specification, however, continues to use phrases such as "the second argument" as a convenient shorthand for "the value of the argument that is bound to the second parameter declaration".

### 1.5 Options

As a matter of convention, a number of functions defined in this document take a parameter whose value is a map, defining options controlling the detail of how the function is evaluated. Maps are a new datatype introduced in XPath 3.1.

For example, the function fn:xml-to-json has an options parameter allowing specification of whether the output is to be indented. A call might be written:

• When the sentence relates to the arguments to a function (for example "The value of $arg must be a valid regular expression") then the implementation is not conformant unless it enforces the condition by raising a dynamic error whenever the condition is not satisfied. • The auxiliary verb may, when rendered in small capitals, indicates optional or discretionary behavior. The statement "An implementation may do X" implies that it is implementation-dependent whether or not it does X. • The auxiliary verb should, when rendered in small capitals, indicates desirable or recommended behavior. The statement "An implementation should do X" implies that it is desirable to do X, but implementations may choose to do otherwise if this is judged appropriate. [Definition] Where behavior is described as implementation-defined, variations between processors are permitted, but a conformant implementation must document the choices it has made. [Definition] Where behavior is described as implementation-dependent, variations between processors are permitted, and conformant implementations are not required to document the choices they have made. Note: Where this specification states that something is implementation-defined or implementation-dependent, it is open to host languages to place further constraints on the behavior. #### 1.7.4 Properties of functions This section is concerned with the question of whether two calls on a function, with the same arguments, may produce different results. [Definition] An execution scope is a sequence of calls to the function library during which certain aspects of the state are required to remain invariant. For example, two calls to fn:current-dateTime within the same execution scope will return the same result. The execution scope is defined by the host language that invokes the function library. In XSLT, for example, any two function calls executed during the same transformation are in the same execution scope (except that static expressions, such as those used in use-when attributes, are in a separate execution scope). The following definition explains more precisely what it means for two function calls to return the same result: [Definition] Two values are defined to be identical if they contain the same number of items and the items are pairwise identical. Two items are identical if and only if one of the following conditions applies: 1. Both items are atomic values, of precisely the same type, and the values are equal as defined using the eq operator, using the Unicode codepoint collation when comparing strings. 2. Both items are nodes, and represent the same node. 3. Both items are maps, both maps have the same number of entries, and for every entry E1 in the first map there is an entry E2 in the second map such that the keys of E1 and E2 are ·the same key·, and the corresponding values V1 and V2 are ·identical·. 4. Both items are arrays, both arrays have the same number of members, and the members are pairwise ·identical·. 5. Both items are function items, neither item is a map or array, and all the following conditions apply: 1. Either both functions have the same name, or both names are absentDM31. 2. Both functions have the same arity. 3. Both functions have the same function signature. Two function signatures are defined to be the same if the declared result types are identical and the declared argument types are pairwise identical. Two types S and T are defined to be identical if and only if subtype(S, T) and subtype(T, S) both hold, where the subtype relation is defined in Section 2.5.6.1 The judgement subtype(A, B) XP31. Note: Under this definition, a union type with memberTypes="xs:double xs:decimal" is identical to a union type with memberTypes="xs:decimal xs:double". However, two functions whose signatures differ in this way will probably be deemed non-identical under rule (e) below, because they are likely to have different effect when invoked with an argument of type xs:untypedAtomic. 4. Both functions have the same nonlocal variable bindings (sometimes called the function's closure). 5. The processor is able to determine that the implementations of the two functions are equivalent, in the sense that for all possible combinations of arguments, the two functions have the same effect. Note: There is no function or operator defined in the specification that tests whether two function items are identical. Where the specification requires two function items to be identical, for example in the results of repeated calls of a function whose result is a function, then the processor must ensure that it returns functions that are indistinguishable in their observable effect. Where the specification defines behavior conditional on two function items being identical, the determination of identity is to some degree implementation-dependent. There are cases where function items are definitely not identical (for example if they have different name or arity), but positive determination of identity is possible only using implementation-dependent techniques, for example when both items contain references to the same piece of code representing the function's implementation. Some functions produce results that depend not only on their explicit arguments, but also on the static and dynamic context. [Definition] A function may have the property of being context-dependent: the result of such a function depends on the values of properties in the static and dynamic evaluation context as well as on the actual supplied arguments (if any). [Definition] A function that is not ·context-dependent· is called context-independent. A function that is context-dependent can be used as a named function reference, can be partially applied, and can be found using fn:function-lookup. The principle in such cases is that the static context used for the function evaluation is taken from the static context of the named function reference, partial function application, or the call on fn:function-lookup; and the dynamic context for the function evaluation is taken from the dynamic context of the evaluation of the named function reference, partial function application, or the call of fn:function-lookup. In effect, the static and dynamic part of the context thus act as part of the closure of the function item. Context-dependent functions fall into a number of categories: 1. The functions fn:current-date, fn:current-dateTime, fn:current-time, fn:default-language, fn:implicit-timezone, fn:adjust-date-to-timezone, fn:adjust-dateTime-to-timezone, and fn:adjust-time-to-timezone depend on properties of the dynamic context that are fixed within the ·execution scope·. The same applies to a number of functions in the op: namespace that manipulate dates and times and that make use of the implicit timezone. These functions will return the same result if called repeatedly during a single ·execution scope·. 2. A number of functions including fn:base-uri#0, fn:data#0, fn:document-uri#0, fn:element-with-id#1, fn:id#1, fn:idref#1, fn:lang#1, fn:last#0, fn:local-name#0, fn:name#0, fn:namespace-uri#0, fn:normalize-space#0, fn:number#0, fn:path#0, fn:position#0, fn:root#0, fn:string#0, and fn:string-length#0 depend on the focusXP31. These functions will in general return different results on different calls if the focus is different. [Definition] A function is focus-dependent if its result depends on the focusXP31 (that is, the context item, position, or size). [Definition] A function that is not ·focus-dependent· is called focus-independent 3. The function fn:default-collation and many string-handling operators and functions depend on the default collation and the in-scope collations, which are both properties of the static context. If a particular call of one of these functions is evaluated twice with the same arguments then it will return the same result each time (because the static context, by definition, does not change at run time). However, two distinct calls (that is, two calls on the function appearing in different places in the source code) may produce different results even if the explicit arguments are the same. 4. Functions such as fn:static-base-uri, fn:doc, and fn:collection depend on other aspects of the static context. As with functions that depend on collations, a single call will produce the same results on each call if the explicit arguments are the same, but two calls appearing in different places in the source code may produce different results. The fn:function-lookup function is a special case because it is potentially dependent on everything in the static and dynamic context. This is because the static and dynamic context of the call to fn:function-lookup are used as the static and dynamic context of the function that fn:function-lookup returns. [Definition] For a ·context-dependent· function, the parts of the context on which it depends are referred to as implicit arguments. [Definition] A function that is guaranteed to produce ·identical· results from repeated calls within a single ·execution scope· if the explicit and implicit arguments are identical is referred to as deterministic. [Definition] A function that is not ·deterministic· is referred to as nondeterministic. All functions defined in this specification are ·deterministic· unless otherwise stated. Exceptions include the following: Where the results of a function are described as being (to a greater or lesser extent) ·implementation-defined· or ·implementation-dependent·, this does not by itself remove the requirement that the results should be deterministic: that is, that repeated calls with the same explicit and implicit arguments must return identical results. ## 2 Accessors Accessors and their semantics are described in [XQuery and XPath Data Model (XDM) 3.1]. Some of these accessors are exposed to the user through the functions described below. Each of these functions has an arity-zero signature which is equivalent to the arity-one form, with the context item supplied as the implicit first argument. In addition, each of the arity-one functions accepts an empty sequence as the argument, in which case it generally delivers an empty sequence as the result: the exception is fn:string, which delivers a zero-length string. Function Accessor Accepts Returns fn:node-name node-name node (optional) xs:QName (optional) fn:nilled nilled node (optional) xs:boolean (optional) fn:string string-value item (optional) xs:string fn:data typed-value zero or more items a sequence of atomic values fn:base-uri base-uri node (optional) xs:anyURI (optional) fn:document-uri document-uri node (optional) xs:anyURI (optional) ### 2.1 fn:node-name Summary Returns the name of a node, as an xs:QName. Signatures  fn:node-name() as xs:QName?  fn:node-name( $node as node()? := . ) as xs:QName?
Properties

The zero-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-dependent·.

The one-argument form of this function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

If the argument is omitted, it defaults to the context item (.). The behavior of the function if the argument is omitted is exactly the same as if the context item had been passed as the argument.

If $node is the empty sequence, the empty sequence is returned. Otherwise, the function returns the result of the dm:node-name accessor as defined in [XQuery and XPath Data Model (XDM) 3.1] (see Section 5.10 node-name AccessorDM40). Error Conditions The following errors may be raised when $node is omitted:

Notes

For element and attribute nodes, the name of the node is returned as an xs:QName, retaining the prefix, namespace URI, and local part.

For processing instructions, the name of the node is returned as an xs:QName in which the prefix and namespace URI are absentDM40.

For a namespace node, the function returns an empty sequence if the node represents the default namespace; otherwise it returns an xs:QName in which prefix and namespace URI are absentDM40 and the local part is the namespace prefix being bound.

For all other kinds of node, the function returns the empty sequence.

### 2.2 fn:nilled

Summary

Returns true for an element that is nilled.

Signatures
 fn:nilled() as xs:boolean?
 fn:nilled( $node as node()? := . ) as xs:boolean? Properties The zero-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-dependent·. The one-argument form of this function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If the argument is omitted, it defaults to the context item (.). The behavior of the function if the argument is omitted is exactly the same as if the context item had been passed as the argument. If $node is the empty sequence, the function returns the empty sequence.

Otherwise the function returns the result of the dm:nilled accessor as defined in [XQuery and XPath Data Model (XDM) 3.1] (see Section 5.8 nilled AccessorDM40).

Error Conditions

The following errors may be raised when $node is omitted: Notes If $node is not an element node, the function returns the empty sequence.

If $node is an untyped element node, the function returns false. In practice, the function returns true only for an element node that has the attribute xsi:nil="true" and that is successfully validated against a schema that defines the element to be nillable; the detailed rules, however, are defined in [XQuery and XPath Data Model (XDM) 3.1]. ### 2.3 fn:string Summary Returns the value of $item represented as an xs:string.

Signatures
 fn:string() as xs:string
 fn:string( $item as item()? := . ) as xs:string Properties The zero-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-dependent·. The one-argument form of this function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules In the zero-argument version of the function, $item defaults to the context item. That is, calling fn:string() is equivalent to calling fn:string(.).

If $item is the empty sequence, the function returns the zero-length string. If $item is a node, the function returns the string value of the node, as obtained using the dm:string-value accessor defined in [XQuery and XPath Data Model (XDM) 3.1] (see Section 5.12 string-value AccessorDM40).

If $item is an atomic value, the function returns the result of the expression $item cast as xs:string (see 19 Casting).

In all other cases, a dynamic error occurs (see below).

Error Conditions

A dynamic error is raised [err:XPDY0002]XP by the zero-argument version of the function if the context item is absentDM40.

A type error is raised [err:FOTY0014] if $item is a function item (this includes maps and arrays). Notes Every node has a string value, even an element with element-only content (which has no typed value). Moreover, casting an atomic value to a string always succeeds. Functions, maps, and arrays have no string value, so these are the only arguments that satisfy the type signature but cause failure. Examples The expression string(23) returns "23". The expression string(false()) returns "false". The expression string("Paris") returns "Paris". The expression string((1, 2, 3)) raises error XPTY0004. The expression string([[1, 2], [3, 4]]) raises error FOTY0014. The expression string(abs#1) raises error FOTY0014. let$para :=
<para>In a hole in the ground there lived a <term author="Tolkien">hobbit</term>.</para>


The expression string($para) returns "In a hole in the ground there lived a hobbit.". ### 2.4 fn:data Summary Returns the result of atomizing a sequence. This process flattens arrays, and replaces nodes by their typed values. Signatures  fn:data() as xs:anyAtomicType*  fn:data( $input as item()* := . ) as xs:anyAtomicType*
Properties

The zero-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-dependent·.

The one-argument form of this function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

If the argument is omitted, it defaults to the context item (.). The behavior of the function if the argument is omitted is exactly the same as if the context item had been passed as the argument.

The result of fn:data is the sequence of atomic values produced by applying the following rules to each item in $input: • If the item is an atomic value, it is appended to the result sequence. • If the item is a node, the typed value of the node is appended to the result sequence. The typed value is a sequence of zero or more atomic values: specifically, the result of the dm:typed-value accessor as defined in [XQuery and XPath Data Model (XDM) 3.1] (See Section 5.14 typed-value AccessorDM40). • If the item is an array, the result of applying fn:data to each member of the array, in order, is appended to the result sequence. Error Conditions A type error is raised [err:FOTY0012] if an item in the sequence $input is a node that does not have a typed value.

A type error is raised [err:FOTY0013] if an item in the sequence $input is a function item other than an array. A dynamic error is raised if $input is omitted and the context item is absentDM40.

Notes

The process of applying the fn:data function to a sequence is referred to as atomization. In many cases an explicit call on fn:data is not required, because atomization is invoked implicitly when a node or sequence of nodes is supplied in a context where an atomic value or sequence of atomic values is required.

The result of atomizing an empty sequence is an empty sequence.

The result of atomizing an empty array is an empty sequence.

Examples

The expression data(123) returns 123.

The expression data((123, 456)) returns 123, 456.

The expression data([[1,2],[3,4]]) returns 1, 2, 3, 4.

let $para := <para>In a hole in the ground there lived a <term author="Tolkien">hobbit</term>.</para>  The expression data($para) returns xs:untypedAtomic("In a hole in the ground there lived a hobbit.").

The expression data($para/term/@author) returns xs:untypedAtomic("Tolkien"). The expression data(abs#1) raises error FOTY0013. ### 2.5 fn:base-uri Summary Returns the base URI of a node. Signatures  fn:base-uri() as xs:anyURI?  fn:base-uri( $node as node()? := . ) as xs:anyURI?
Properties

The zero-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-dependent·.

The one-argument form of this function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

The zero-argument version of the function returns the base URI of the context node: it is equivalent to calling fn:base-uri(.).

The single-argument version of the function behaves as follows:

1. If $node is the empty sequence, the function returns the empty sequence. 2. Otherwise, the function returns the value of the dm:base-uri accessor applied to the node $node. This accessor is defined, for each kind of node, in the XDM specification (See Section 5.2 base-uri AccessorDM40).

Note:

As explained in XDM, document, element and processing-instruction nodes have a base-uri property which may be empty. The base-uri property for all other node kinds is the empty sequence. The dm:base-uri accessor returns the base-uri property of a node if it exists and is non-empty; otherwise it returns the result of applying the dm:base-uri accessor to its parent, recursively. If the node does not have a parent, or if the recursive ascent up the ancestor chain encounters a parentless node whose base-uri property is empty, the empty sequence is returned. In the case of namespace nodes, however, the result is always an empty sequence — it does not depend on the base URI of the parent element.

See also fn:static-base-uri.

Error Conditions

The following errors may be raised when $node is omitted: ### 2.6 fn:document-uri Summary Returns the URI of a resource where a document can be found, if available. Signatures  fn:document-uri() as xs:anyURI?  fn:document-uri( $node as node()? := . ) as xs:anyURI?
Properties

The zero-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-dependent·.

The one-argument form of this function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

If the argument is omitted, it defaults to the context item (.). The behavior of the function if the argument is omitted is exactly the same as if the context item had been passed as the argument.

If $node is the empty sequence, the function returns the empty sequence. If $node is not a document node, the function returns the empty sequence.

Otherwise, the function returns the value of the document-uri accessor applied to $node, as defined in [XQuery and XPath Data Model (XDM) 3.1] (See Section 6.1.2 AccessorsDM40). Error Conditions The following errors may be raised when $node is omitted:

Notes

In the case of a document node $D returned by the fn:doc function, or a document node at the root of a tree containing a node returned by the fn:collection function, it will always be true that either fn:document-uri($D) returns the empty sequence, or that the following expression is true: fn:doc(fn:document-uri($D)) is $D. It is ·implementation-defined· whether this guarantee also holds for document nodes obtained by other means, for example a document node passed as the initial context node of a query or transformation.

A consequence of these rules is that it is not possible (within the execution scope of a transformation) for two different documents to have the same value for their document-uri property. This means that in situations where URI stability is not guaranteed (for example, with streamed input documents in XSLT, or for documents returned by fn:collection if document stability has been disabled), the document-uri property should be absent, and fn:document-uri should return an empty sequence.

## 3 Errors and diagnostics

### 3.1 Raising errors

In this document, as well as in [XQuery 4.1: An XML Query Language] and [XML Path Language (XPath) 4.0], the phrase "an error is raised" is used. Raising an error is equivalent to calling the fn:error function defined in this section with the provided error code. Except where otherwise specified, errors defined in this specification are dynamic errors. Some errors, however, are classified as type errors. Type errors are typically used where the presence of the error can be inferred from knowledge of the type of the actual arguments to a function, for example with a call such as fn:string(fn:abs#1). Host languages may allow type errors to be reported statically if they are discovered during static analysis.

When function specifications indicate that an error is to be raised, the notation "[error code]". os used to specify an error code. Each error defined in this document is identified by an xs:QName that is in the http://www.w3.org/2005/xqt-errors namespace, represented in this document by the err prefix. It is this xs:QName that is actually passed as an argument to the fn:error function. Calling this function raises an error. For a more detailed treatment of error handing, see Section 2.3.3 Handling Dynamic Errors XP31.

The fn:error function is a general function that may be called as above but may also be called from [XQuery 4.1: An XML Query Language] or [XML Path Language (XPath) 4.0] applications with, for example, an xs:QName argument.

#### 3.1.1 fn:error

Summary

Calling the fn:error function raises an application-defined error.

Signatures
 fn:error() as none
 fn:error( $code as xs:QName? ) as none  fn:error( $code as xs:QName?, $description as xs:string ) as none  fn:error( $code as xs:QName?, $description as xs:string, $error-object as item()* := . ) as none
Properties

This function is ·nondeterministic·, ·context-independent·, and ·focus-independent·.

Rules

This function never returns a value. Instead it always raises an error. The effect of the error is identical to the effect of dynamic errors raised implicitly, for example when an incorrect argument is supplied to a function.

The parameters to the fn:error function supply information that is associated with the error condition and that is made available to a caller that asks for information about the error. The error may be caught either by the host language (using a try/catch construct in XSLT or XQuery, for example), or by the calling application or external processing environment. The way in which error information is returned to the external processing environment is ·implementation-dependent·.

There are three pieces of information that may be associated with an error:

• The $code is an error code that distinguishes this error from others. It is an xs:QName; the namespace URI conventionally identifies the component, subsystem, or authority responsible for defining the meaning of the error code, while the local part identifies the specific error condition. The namespace URI http://www.w3.org/2005/xqt-errors is used for errors defined in this specification; other namespace URIs may be used for errors defined by the application. If the external processing environment expects the error code to be returned as a URI or a string rather than as an xs:QName, then an error code with namespace URI NS and local part LP will be returned in the form NS#LP. The namespace URI part of the error code should therefore not include a fragment identifier. If no value is supplied for the $code argument (that is, if the function is called with no arguments or if the first argument is an empty sequence), the effective value of the error code is fn:QName('http://www.w3.org/2005/xqt-errors', 'err:FOER0000').

• The $description is a natural-language description of the error condition. If no value is supplied for the $description argument (that is, if the function is called with less than two arguments), then the effective value of the description is ·implementation-dependent·.

• The $error-object is an arbitrary value used to convey additional information about the error, and may be used in any way the application chooses. If no value is supplied for the $error-object argument (that is, if the function is called with less than three arguments), then the effective value of the error object is ·implementation-dependent·.

Error Conditions

This function always raises a dynamic error. By default, it raises [err:FOER0000]

Notes

The value of the $description parameter may need to be localized. The type "none" is a special type defined in [XQuery 1.0 and XPath 2.0 Formal Semantics] and is not available to the user. It indicates that the function never returns and ensures that it has the correct static type. Any QName may be used as an error code; there are no reserved names or namespaces. The error is always classified as a dynamic error, even if the error code used is one that is normally used for static errors or type errors. Examples The expression fn:error() raises error FOER0000. (This returns the URI http://www.w3.org/2005/xqt-errors#FOER0000 (or the corresponding xs:QName) to the external processing environment, unless the error is caught using a try/catch construct in the host language.) The expression fn:error(fn:QName('http://www.example.com/HR', 'myerr:toohighsal'), 'Does not apply because salary is too high') raises error myerr:toohighsal. (This returns http://www.example.com/HR#toohighsal and the xs:string "Does not apply because salary is too high" (or the corresponding xs:QName) to the external processing environment, unless the error is caught using a try/catch construct in the host language.) ### 3.2 Diagnostic tracing #### 3.2.1 fn:trace Summary Provides an execution trace intended to be used in debugging queries. Signatures  fn:trace( $value as item()* ) as item()*
 fn:trace( $value as item()*, $label as xs:string ) as item()*
Properties

This function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

The function returns $value, unchanged. In addition, the values of $value, converted to an xs:string, and $label (if supplied) may be directed to a trace data set. The destination of the trace output is ·implementation-defined·. The format of the trace output is ·implementation-dependent·. The ordering of output from calls of the fn:trace function is ·implementation-dependent·. Notes Sometimes there is a need to output trace information unrelated to a specific value. In such cases it can be useful to set $value to an empty string or an empty sequence, and to compute the value of the $label argument: fn:trace((), "Processing item " ||$i).

Examples

Consider a situation in which a user wants to investigate the actual value passed to a function. Assume that in a particular execution, $v is an xs:decimal with value 124.84. Writing fn:trace($v, 'the value of $v is:') will put the strings "124.84" and "the value of$v is:" in the trace data set in implementation dependent order.

#### 3.2.2 fn:stack-trace

Summary

Returns implementation-dependent information about the current state of execution.

Signature
 fn:stack-trace() as xs:string
Rules

The result of the function is an implementation-dependent string containing diagnostic information about the current state of execution.

The function is non-deterministic: multiple calls will typically produce different results.

Notes

The function will typically be called to assist in diagnosing dynamic errors.

## 4 Functions and operators on numerics

This section specifies arithmetic operators on the numeric datatypes defined in [XML Schema Part 2: Datatypes Second Edition].

### 4.1 Numeric types

The operators described in this section are defined on the following atomic types. Each type whose name is indented is derived from the type whose name appears nearest above with one less level of indentation.

 xs:decimal xs:integer xs:float xs:double

They also apply to types derived by restriction from the above types.

The type xs:numeric is defined as a union type whose member types are (in order) xs:double, xs:float, and xs:decimal. This type is implicitly imported into the static context, so it can also be used in defining the signature of user-written functions. Apart from the fact that it is implicitly imported, it behaves exactly like a user-defined type with the same definition. This means, for example:

• If the expected type of a function parameter is given as xs:numeric, the actual value supplied can be an instance of any of these three types, or any type derived from these three by restriction (this includes the built-in type xs:integer, which is derived from xs:decimal).

• If the expected type of a function parameter is given as xs:numeric, and the actual value supplied is xs:untypedAtomic (or a node whose atomized value is xs:untypedAtomic), then it will be cast to the union type xs:numeric using the rules in 19.3.5 Casting to union types. Because the lexical space of xs:double subsumes the lexical space of the other member types, and xs:double is listed first, the effect is that if the untyped atomic value is in the lexical space of xs:double, it will be converted to an xs:double, and if not, a dynamic error occurs.

• When the return type of a function is given as xs:numeric, the actual value returned will be an instance of one of the three member types (and perhaps also of types derived from these by restriction). The rules for the particular function will specify how the type of the result depends on the values supplied as arguments. In many cases, for the functions in this specification, the result is defined to be the same type as the first argument.

Note:

This specification uses [IEEE 754-2008] arithmetic for xs:float and xs:double values. One consequence of this is that some operations result in the value NaN (not-a number), which has the unusual property that it is not equal to itself. Another consequence is that some operations return the value negative zero. This differs from [XML Schema Part 2: Datatypes Second Edition] which defines NaN as being equal to itself and defines only a single zero in the value space. The text accompanying several functions defines behavior for both positive and negative zero inputs and outputs in the interest of alignment with [IEEE 754-2008]. A conformant implementation must respect these semantics. In consequence, the expression -0.0e0 (which is actually a unary minus operator applied to an xs:double value) will always return negative zero: see 4.2.8 op:numeric-unary-minus. As a concession to implementations that rely on implementations of XSD 1.0, however, when casting from string to double the lexical form -0 may be converted to positive zero, though negative zero is recommended.

XML Schema 1.1 introduces support for positive and negative zero as distinct values, and also uses the [IEEE 754-2008] semantics for comparisons involving NaN.

### 4.2 Arithmetic operators on numeric values

The following functions define the semantics of arithmetic operators defined in [XQuery 4.1: An XML Query Language] and [XML Path Language (XPath) 4.0] on these numeric types.

Operator Meaning
op:numeric-add Addition
op:numeric-subtract Subtraction
op:numeric-multiply Multiplication
op:numeric-divide Division
op:numeric-integer-divide Integer division
op:numeric-mod Modulus
op:numeric-unary-plus Unary plus
op:numeric-unary-minus Unary minus (negation)

The parameters and return types for the above operators are in most cases declared to be of type xs:numeric, which permits the basic numeric types: xs:integer, xs:decimal, xs:float and xs:double, and types derived from them. In general the two-argument functions require that both arguments are of the same primitive type, and they return a value of this same type. The exceptions are op:numeric-divide, which returns an xs:decimal if called with two xs:integer operands, and op:numeric-integer-divide which always returns an xs:integer.

If the two operands of an arithmetic expression are not of the same type, subtype substitution and numeric type promotion are used to obtain two operands of the same type. Section B.1 Type Promotion XP31 and Section B.2 Operator Mapping XP31 describe the semantics of these operations in detail.

The result type of operations depends on their argument datatypes and is defined in the following table:

Operator Returns
op:operation(xs:integer, xs:integer) xs:integer (except for op:numeric-divide(integer, integer), which returns xs:decimal)
op:operation(xs:decimal, xs:decimal) xs:decimal
op:operation(xs:float, xs:float) xs:float
op:operation(xs:double, xs:double) xs:double
op:operation(xs:integer) xs:integer
op:operation(xs:decimal) xs:decimal
op:operation(xs:float) xs:float
op:operation(xs:double) xs:double

These rules define any operation on any pair of arithmetic types. Consider the following example:

op:operation(xs:int, xs:double) => op:operation(xs:double, xs:double)

For this operation, xs:int must be converted to xs:double. This can be done, since by the rules above: xs:int can be substituted for xs:integer, xs:integer can be substituted for xs:decimal, xs:decimal can be promoted to xs:double. As far as possible, the promotions should be done in a single step. Specifically, when an xs:decimal is promoted to an xs:double, it should not be converted to an xs:float and then to xs:double, as this risks loss of precision.

As another example, a user may define height as a derived type of xs:integer with a minimum value of 20 and a maximum value of 100. They may then derive fenceHeight using an enumeration to restrict the permitted set of values to, say, 36, 48 and 60.

op:operation(fenceHeight, xs:integer) => op:operation(xs:integer, xs:integer)

fenceHeight can be substituted for its base type height and height can be substituted for its base type xs:integer.

The basic rules for addition, subtraction, and multiplication of ordinary numbers are not set out in this specification; they are taken as given. In the case of xs:double and xs:float the rules are as defined in [IEEE 754-2008]. The rules for handling division and modulus operations, as well as the rules for handling special values such as infinity and NaN, and exception conditions such as overflow and underflow, are described more explicitly since they are not necessarily obvious.

On overflow and underflow situations during arithmetic operations conforming implementations must behave as follows:

• For xs:float and xs:double operations, overflow behavior must be conformant with [IEEE 754-2008]. This specification allows the following options:

• Raising a dynamic error [err:FOAR0002] via an overflow trap.

• Returning INF or -INF.

• Returning the largest (positive or negative) non-infinite number.

• For xs:float and xs:double operations, underflow behavior must be conformant with [IEEE 754-2008]. This specification allows the following options:

• Raising a dynamic error [err:FOAR0002] via an underflow trap.

• Returning 0.0E0 or +/- 2**Emin or a denormalized value; where Emin is the smallest possible xs:float or xs:double exponent.

• For xs:decimal operations, overflow behavior must raise a dynamic error [err:FOAR0002]. On underflow, 0.0 must be returned.

• For xs:integer operations, implementations that support limited-precision integer operations must select from the following options:

• They may choose to always raise a dynamic error [err:FOAR0002].

• They may provide an ·implementation-defined· mechanism that allows users to choose between raising an error and returning a result that is modulo the largest representable integer value. See [ISO 10967].

The functions op:numeric-add, op:numeric-subtract, op:numeric-multiply, op:numeric-divide, op:numeric-integer-divide and op:numeric-mod are each defined for pairs of numeric operands, each of which has the same type:xs:integer, xs:decimal, xs:float, or xs:double. The functions op:numeric-unary-plus and op:numeric-unary-minus are defined for a single operand whose type is one of those same numeric types.

For xs:float and xs:double arguments, if either argument is NaN, the result is NaN.

For xs:decimal values, let N be the number of digits of precision supported by the implementation, and let M (M <= N) be the minimum limit on the number of digits required for conformance (18 digits for XSD 1.0, 16 digits for XSD 1.1). Then for addition, subtraction, and multiplication operations, the returned result should be accurate to N digits of precision, and for division and modulus operations, the returned result should be accurate to at least M digits of precision. The actual precision is ·implementation-defined·. If the number of digits in the mathematical result exceeds the number of digits that the implementation retains for that operation, the result is truncated or rounded in an ·implementation-defined· manner.

Note:

This Recommendation does not specify whether xs:decimal operations are fixed point or floating point. In an implementation using floating point it is possible for very simple operations to require more digits of precision than are available; for example adding 1e100 to 1e-100 requires 200 digits of precision for an accurate representation of the result.

The [IEEE 754-2008] specification also describes handling of two exception conditions called divideByZero and invalidOperation. The IEEE divideByZero exception is raised not only by a direct attempt to divide by zero, but also by operations such as log(0). The IEEE invalidOperation exception is raised by attempts to call a function with an argument that is outside the function's domain (for example, sqrt(-1) or log(-1)). Although IEEE defines these as exceptions, it also defines "default non-stop exception handling" in which the operation returns a defined result, typically positive or negative infinity, or NaN. With this function library, these IEEE exceptions do not cause a dynamic error at the application level; rather they result in the relevant function or operator returning the defined non-error result. The underlying IEEE exception may be notified to the application or to the user by some ·implementation-defined· warning condition, but the observable effect on an application using the functions and operators defined in this specification is simply to return the defined result (typically -INF, +INF, or NaN) with no error.

The [IEEE 754-2008] specification distinguishes two NaN values, a quiet NaN and a signaling NaN. These two values are not distinguishable in the XDM model: the value spaces of xs:float and xs:double each include only a single NaN value. This does not prevent the implementation distinguishing them internally, and triggering different ·implementation-defined· warning conditions, but such distinctions do not affect the observable behavior of an application using the functions and operators defined in this specification.

Summary

Returns the arithmetic sum of its operands: ($arg1 +$arg2).

Operator Mapping

Defines the semantics of the "+" operator when applied to two numeric values

Signature
 op:numeric-add( $arg1 as xs:numeric, $arg2 as xs:numeric ) as xs:numeric
Rules

General rules: see 4.2 Arithmetic operators on numeric values.

Notes

For xs:float or xs:double values, if one of the operands is a zero or a finite number and the other is INF or -INF, INF or -INF is returned. If both operands are INF, INF is returned. If both operands are -INF, -INF is returned. If one of the operands is INF and the other is -INF, NaN is returned.

#### 4.2.2 op:numeric-subtract

Summary

Returns the arithmetic difference of its operands: ($arg1 -$arg2).

Operator Mapping

Defines the semantics of the "-" operator when applied to two numeric values.

Signature
 op:numeric-subtract( $arg1 as xs:numeric, $arg2 as xs:numeric ) as xs:numeric
Rules

General rules: see 4.2 Arithmetic operators on numeric values.

Notes

For xs:float or xs:double values, if one of the operands is a zero or a finite number and the other is INF or -INF, an infinity of the appropriate sign is returned. If both operands are INF or -INF, NaN is returned. If one of the operands is INF and the other is -INF, an infinity of the appropriate sign is returned.

#### 4.2.3 op:numeric-multiply

Summary

Returns the arithmetic product of its operands: ($arg1 *$arg2).

Operator Mapping

Defines the semantics of the "*" operator when applied to two numeric values.

Signature
 op:numeric-multiply( $arg1 as xs:numeric, $arg2 as xs:numeric ) as xs:numeric
Rules

General rules: see 4.2 Arithmetic operators on numeric values.

Notes

For xs:float or xs:double values, if one of the operands is a zero and the other is an infinity, NaN is returned. If one of the operands is a non-zero number and the other is an infinity, an infinity with the appropriate sign is returned.

#### 4.2.4 op:numeric-divide

Summary

Returns the arithmetic quotient of its operands: ($arg1 div$arg2).

Operator Mapping

Defines the semantics of the "div" operator when applied to two numeric values.

Signature
 op:numeric-divide( $arg1 as xs:numeric, $arg2 as xs:numeric ) as xs:numeric
Rules

General rules: see 4.2 Arithmetic operators on numeric values.

As a special case, if the types of both $arg1 and $arg2 are xs:integer, then the return type is xs:decimal.

Error Conditions

A dynamic error is raised [err:FOAR0001] for xs:decimal and xs:integer operands, if the divisor is (positive or negative) zero.

Notes

For xs:float and xs:double operands, floating point division is performed as specified in [IEEE 754-2008]. A positive number divided by positive zero returns INF. A negative number divided by positive zero returns -INF. Division by negative zero returns -INF and INF, respectively. Positive or negative zero divided by positive or negative zero returns NaN. Also, INF or -INF divided by INF or -INF returns NaN.

#### 4.2.5 op:numeric-integer-divide

Summary

Performs an integer division.

Operator Mapping

Defines the semantics of the "idiv" operator when applied to two numeric values.

Signature
 op:numeric-integer-divide( $arg1 as xs:numeric, $arg2 as xs:numeric ) as xs:integer
Rules

General rules: see 4.2 Arithmetic operators on numeric values.

If $arg2 is INF or -INF, and $arg1 is not INF or -INF, then the result is zero.

Otherwise, subject to limits of precision and overflow/underflow conditions, the result is the largest (furthest from zero) xs:integer value $N such that the following expression is true: fn:abs($N * $arg2) le fn:abs($arg1)
and fn:compare($N *$arg2, 0) eq fn:compare($arg1, 0). Note: The second term in this condition ensures that the result has the correct sign. The implementation may adopt a different algorithm provided that it is equivalent to this formulation in all cases where ·implementation-dependent· or ·implementation-defined· behavior does not affect the outcome, for example, the implementation-defined precision of the result of xs:decimal division. Error Conditions A dynamic error is raised [err:FOAR0001] if the divisor is (positive or negative) zero. A dynamic error is raised [err:FOAR0002] if either operand is NaN or if $arg1 is INF or -INF.

Notes

Except in situations involving errors, loss of precision, or overflow/underflow, the result of $a idiv$b is the same as ($a div$b) cast as xs:integer.

The semantics of this function are different from integer division as defined in programming languages such as Java and C++.

Examples

The expression op:numeric-integer-divide(10,3) returns 3.

The expression op:numeric-integer-divide(3,-2) returns -1.

The expression op:numeric-integer-divide(-3,2) returns -1.

The expression op:numeric-integer-divide(-3,-2) returns 1.

The expression op:numeric-integer-divide(9.0,3) returns 3.

The expression op:numeric-integer-divide(-3.5,3) returns -1.

The expression op:numeric-integer-divide(3.0,4) returns 0.

The expression op:numeric-integer-divide(3.1E1,6) returns 5.

The expression op:numeric-integer-divide(3.1E1,7) returns 4.

#### 4.2.6 op:numeric-mod

Summary

Returns the remainder resulting from dividing $arg1, the dividend, by $arg2, the divisor.

Operator Mapping

Defines the semantics of the "mod" operator when applied to two numeric values.

Signature
 op:numeric-mod( $arg1 as xs:numeric, $arg2 as xs:numeric ) as xs:numeric
Rules

General rules: see 4.2 Arithmetic operators on numeric values.

The operation a mod b for operands that are xs:integer or xs:decimal, or types derived from them, produces a result such that (a idiv b)*b+(a mod b) is equal to a and the magnitude of the result is always less than the magnitude of b. This identity holds even in the special case that the dividend is the negative integer of largest possible magnitude for its type and the divisor is -1 (the remainder is 0). It follows from this rule that the sign of the result is the sign of the dividend.

For xs:float and xs:double operands the following rules apply:

• If either operand is NaN, the result is NaN.

• If the dividend is positive or negative infinity, or the divisor is positive or negative zero (0), or both, the result is NaN.

• If the dividend is finite and the divisor is an infinity, the result equals the dividend.

• If the dividend is positive or negative zero and the divisor is finite, the result is the same as the dividend.

• In the remaining cases, where neither positive or negative infinity, nor positive or negative zero, nor NaN is involved, the result obeys (a idiv b)*b+(a mod b) = a. Division is truncating division, analogous to integer division, not [IEEE 754-2008] rounding division i.e. additional digits are truncated, not rounded to the required precision.

Error Conditions

A dynamic error is raised [err:FOAR0001] for xs:integer and xs:decimal operands, if $arg2 is zero. Examples The expression op:numeric-mod(10,3) returns 1. The expression op:numeric-mod(6,-2) returns 0. The expression op:numeric-mod(4.5,1.2) returns 0.9. The expression op:numeric-mod(1.23E2, 0.6E1) returns 3.0E0. #### 4.2.7 op:numeric-unary-plus Summary Returns its operand with the sign unchanged: (+$arg).

Operator Mapping

Defines the semantics of the unary "+" operator applied to a numeric value.

Signature
 op:numeric-unary-plus( $arg as xs:numeric ) as xs:numeric Rules General rules: see 4.2 Arithmetic operators on numeric values. The returned value is equal to $arg, and is an instance of xs:integer, xs:decimal, xs:double, or xs:float depending on the type of $arg. Notes Because function conversion rules are applied in the normal way, the unary + operator can be used to force conversion of an untyped node to a number: the result of +@price is the same as xs:double(@price) if the type of @price is xs:untypedAtomic. #### 4.2.8 op:numeric-unary-minus Summary Returns its operand with the sign reversed: (-$arg).

Operator Mapping

Defines the semantics of the unary "-" operator when applied to a numeric value.

Signature
 op:numeric-unary-minus( $arg as xs:numeric ) as xs:numeric Rules General rules: see 4.2 Arithmetic operators on numeric values. The returned value is an instance of xs:integer, xs:decimal, xs:double, or xs:float depending on the type of $arg.

For xs:integer and xs:decimal arguments, 0 and 0.0 return 0 and 0.0, respectively. For xs:float and xs:double arguments, NaN returns NaN, 0.0E0 returns -0.0E0 and vice versa. INF returns -INF. -INF returns INF.

### 4.3 Comparison operators on numeric values

The six value comparison operators eq, ne, lt, le, gt, and ge are defined in terms of two underlying functions: op:numeric-equal and op:numeric-less-than. These functions are defined to operate on values of the same type.

If the arguments are of different types, then one of them is converted to the type of the other using the following rules, in order:

1. If one operand is xs:float then it is converted to xs:double.

2. If one operand is xs:double and the other is xs:decimal, then:

1. If the xs:double operand is -INF, +INF, or NaN, then the xs:decimal value is cast to xs:double and the values are compared as doubles.

2. Otherwise, the xs:double value is converted to a decimal number with no rounding or loss of precision and the values are compared acccording to their mathematical values.

Note:

Every instance of xs:float, xs:double, and xs:decimal, other than the values -INF, +INF, and NaN, can be represented exactly as a decimal number provided enough digits are available both before and after the decimal point. The effect of this rule is that the comparison operators are transitive.

In edge cases this rule may give a different result from earlier releases. For example in XPath 3.1 (depending on the implementation-defined precision), the values xs:decimal('1.0000000000100000000001') and xs:double('1.00000000001') might compare as equal; in this version of the specification, they are not equal.

This change removes the problems caused for fn:distinct-values and xsl:for-each-group as a result of non-transitivity, and it aligns the semantics of the eq operator (used also in fn:distinct-values, fn:index-of, and fn:deep-equal) with the semantics of the op:same-key comparison used for maps.

This specification defines the following comparison operators on numeric values. Each comparison operator returns a boolean value. If either, or both, operands are NaN, false is returned.

Function Meaning
op:numeric-equal Returns true if and only if the value of $arg1 is equal to the value of $arg2.
op:numeric-less-than Returns true if and only if $arg1 is numerically less than $arg2.

#### 4.3.1 op:numeric-equal

Summary

Returns true if and only if the value of $arg1 is equal to the value of $arg2.

Operator Mapping

Defines the semantics of the "eq" operator when applied to two numeric values, and is also used in defining the semantics of "ne", "le" and "ge".

Signature
 op:numeric-equal( $arg1 as xs:numeric, $arg2 as xs:numeric ) as xs:boolean
Rules

General rules: see 4.3 Comparison operators on numeric values.

The two arguments will always have been converted so they have the same primitive type (both xs:float, both xs:double, or both xs:decimal. The values are compared using the equality rules defined in [XML Schema Part 2: Datatypes Second Edition].

Notes

Positive and negative zero compare equal. If $arg1 or $arg2 is NaN, the function returns false.

#### 4.3.2 op:numeric-less-than

Summary

Returns true if and only if $arg1 is numerically less than $arg2.

Operator Mapping

Defines the semantics of the lt operator when applied to two numeric values, and is also used in defining the semantics of le, gt, and ge.

Signature
 op:numeric-less-than( $arg1 as xs:numeric, $arg2 as xs:numeric ) as xs:boolean
Rules

General rules: see 4.3 Comparison operators on numeric values.

The two arguments will always have been converted so they have the same primitive type (both xs:float, both xs:double, or both xs:decimal. The values are compared using the ordering rules defined in [XML Schema Part 2: Datatypes Second Edition]. If the ordering relation of the two values is imcomparable (which happens when one or both of them is NaN, then the result is false.

Notes

For xs:float and xs:double values, positive infinity is greater than all other non-NaN values; negative infinity is less than all other non-NaN values. Positive and negative zero compare equal. If $arg1 or $arg2 is NaN, the function returns false.

### 4.4 Functions on numeric values

The following functions are defined on numeric types. Each function returns a value of the same type as the type of its argument.

• If the argument is the empty sequence, the empty sequence is returned.

• For xs:float and xs:double arguments, if the argument is "NaN", "NaN" is returned.

• Except for fn:abs, for xs:float and xs:double arguments, if the argument is positive or negative infinity, positive or negative infinity is returned.

Function Meaning
fn:abs Returns the absolute value of $value. fn:ceiling Rounds $value upwards to a whole number.
fn:floor Rounds $value downwards to a whole number. fn:round Rounds a value to a specified number of decimal places, rounding upwards if two such values are equally near. fn:round-half-to-even Rounds a value to a specified number of decimal places, rounding to make the last digit even if two such values are equally near. fn:is-NaN Returns true if the argument is the xs:float or xs:double value NaN. Note: fn:round and fn:round-half-to-even produce the same result in all cases except when the argument is exactly midway between two values with the required precision. Other ways of rounding midway values can be achieved as follows: • Towards negative infinity: -fn:round(-$x)

• Away from zero: fn:round(fn:abs($x))*fn:compare($x,0)

• Towards zero: fn:abs(fn:round(-$x))*-fn:compare($x,0)

#### 4.4.1 fn:abs

Summary

Returns the absolute value of $value. Signature  fn:abs( $value as xs:numeric? ) as xs:numeric?
Properties

This function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

General rules: see 4.4 Functions on numeric values.

If $value is negative the function returns -$value, otherwise it returns $value. For the four types xs:float, xs:double, xs:decimal and xs:integer, it is guaranteed that if the type of $value is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if $value is an instance of xs:positiveInteger then the value of $value may be returned unchanged.

For xs:float and xs:double arguments, if the argument is positive zero or negative zero, then positive zero is returned. If the argument is positive or negative infinity, positive infinity is returned.

Examples

The expression fn:abs(10.5) returns 10.5.

The expression fn:abs(-10.5) returns 10.5.

#### 4.4.2 fn:ceiling

Summary

Rounds $value upwards to a whole number. Signature  fn:ceiling( $value as xs:numeric? ) as xs:numeric?
Properties

This function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

General rules: see 4.4 Functions on numeric values.

The function returns the smallest (closest to negative infinity) number with no fractional part that is not less than $value. For the four types xs:float, xs:double, xs:decimal and xs:integer, it is guaranteed that if the type of $value is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if $value is an instance of xs:decimal then the result may be an instance of xs:integer. For xs:float and xs:double arguments, if the argument is positive zero, then positive zero is returned. If the argument is negative zero, then negative zero is returned. If the argument is less than zero and greater than -1, negative zero is returned. Examples The expression fn:ceiling(10.5) returns 11. The expression fn:ceiling(-10.5) returns -10. #### 4.4.3 fn:floor Summary Rounds $value downwards to a whole number.

Signature
 fn:floor( $value as xs:numeric? ) as xs:numeric? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules General rules: see 4.4 Functions on numeric values. The function returns the largest (closest to positive infinity) number with no fractional part that is not greater than $value.

For the four types xs:float, xs:double, xs:decimal and xs:integer, it is guaranteed that if the type of $value is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if $value is an instance of xs:decimal then the result may be an instance of xs:integer.

For xs:float and xs:double arguments, if the argument is positive zero, then positive zero is returned. If the argument is negative zero, then negative zero is returned.

Examples

The expression fn:floor(10.5) returns 10.

The expression fn:floor(-10.5) returns -11.

#### 4.4.4 fn:round

Summary

Rounds a value to a specified number of decimal places, rounding upwards if two such values are equally near.

Signatures
 fn:round( $value as xs:numeric? ) as xs:numeric?  fn:round( $value as xs:numeric?, $precision as xs:integer ) as xs:numeric? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules General rules: see 4.4 Functions on numeric values. The function returns the nearest (that is, numerically closest) value to $value that is a multiple of ten to the power of minus $precision. If two such values are equally near (for example, if the fractional part in $value is exactly .5), the function returns the one that is closest to positive infinity.

For the four types xs:float, xs:double, xs:decimal and xs:integer, it is guaranteed that if the type of $value is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if $value is an instance of xs:decimal and $precision is less than one, then the result may be an instance of xs:integer. The single-argument version of this function produces the same result as the two-argument version with $precision=0 (that is, it rounds to a whole number).

When $value is of type xs:float and xs:double: 1. If $value is NaN, positive or negative zero, or positive or negative infinity, then the result is the same as the argument.

2. For other values, the argument is cast to xs:decimal using an implementation of xs:decimal that imposes no limits on the number of digits that can be represented. The function is applied to this xs:decimal value, and the resulting xs:decimal is cast back to xs:float or xs:double as appropriate to form the function result. If the resulting xs:decimal value is zero, then positive or negative zero is returned according to the sign of $value. Notes This function is typically used with a non-zero $precision in financial applications where the argument is of type xs:decimal. For arguments of type xs:float and xs:double the results may be counter-intuitive. For example, consider round(35.425e0, 2). The result is not 35.43, as might be expected, but 35.42. This is because the xs:double written as 35.425e0 has an exact value equal to 35.42499999999..., which is closer to 35.42 than to 35.43.

Examples

The expression fn:round(2.5) returns 3.0.

The expression fn:round(2.4999) returns 2.0.

The expression fn:round(-2.5) returns -2.0. (Not the possible alternative, -3).

The expression fn:round(1.125, 2) returns 1.13.

The expression fn:round(8452, -2) returns 8500.

The expression fn:round(3.1415e0, 2) returns 3.14e0.

#### 4.4.5 fn:round-half-to-even

Summary

Rounds a value to a specified number of decimal places, rounding to make the last digit even if two such values are equally near.

Signatures
 fn:round-half-to-even( $value as xs:numeric? ) as xs:numeric?  fn:round-half-to-even( $value as xs:numeric?, $precision as xs:integer ) as xs:numeric? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules General rules: see 4.4 Functions on numeric values. The function returns the nearest (that is, numerically closest) value to $value that is a multiple of ten to the power of minus $precision. If two such values are equally near (e.g. if the fractional part in $value is exactly .500...), the function returns the one whose least significant digit is even.

For the four types xs:float, xs:double, xs:decimal and xs:integer, it is guaranteed that if the type of $value is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if $value is an instance of xs:decimal and $precision is less than one, then the result may be an instance of xs:integer. The first signature of this function produces the same result as the second signature with $precision=0.

For arguments of type xs:float and xs:double:

1. If the argument is NaN, positive or negative zero, or positive or negative infinity, then the result is the same as the argument.

2. In all other cases, the argument is cast to xs:decimal using an implementation of xs:decimal that imposes no limits on the number of digits that can be represented. The function is applied to this xs:decimal value, and the resulting xs:decimal is cast back to xs:float or xs:double as appropriate to form the function result. If the resulting xs:decimal value is zero, then positive or negative zero is returned according to the sign of the original argument.

Notes

This function is typically used in financial applications where the argument is of type xs:decimal. For arguments of type xs:float and xs:double the results may be counter-intuitive. For example, consider round-half-to-even(xs:float(150.015), 2). The result is not 150.02 as might be expected, but 150.01. This is because the conversion of the xs:float value represented by the literal 150.015 to an xs:decimal produces the xs:decimal value 150.014999389..., which is closer to 150.01 than to 150.02.

Examples

The expression fn:round-half-to-even(0.5) returns 0.0.

The expression fn:round-half-to-even(1.5) returns 2.0.

The expression fn:round-half-to-even(2.5) returns 2.0.

The expression fn:round-half-to-even(3.567812e+3, 2) returns 3567.81e0.

The expression fn:round-half-to-even(4.7564e-3, 2) returns 0.0e0.

The expression fn:round-half-to-even(35612.25, -2) returns 35600.

#### 4.4.6 fn:is-NaN

Summary

Returns true if the argument is the xs:float or xs:double value NaN.

Signature
 fn:is-NaN( $value as xs:anyAtomicType ) as xs:boolean Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules The function returns true if the argument is the xs:float or xs:double value NaN; otherwise it returns false. Examples The expression fn:is-NaN(23) returns false(). The expression fn:is-NaN("NaN") returns false(). The expression fn:is-NaN(fn:number("twenty-three")) returns true(). The expression fn:is-NaN(math:sqrt(-1)) returns true(). History New in 4.0. Accepted 2022-09-20. ### 4.5 Parsing numbers It is possible to convert strings to values of type xs:integer, xs:float, xs:decimal, or xs:double using the constructor functions described in 18 Constructor functions or using cast expressions as described in 19 Casting. In addition the fn:number function is available to convert strings to values of type xs:double. It differs from the xs:double constructor function in that any value outside the lexical space of the xs:double datatype is converted to the xs:double value NaN. Function Meaning fn:number Returns the value indicated by $value or, if $value is not specified, the context item after atomization, converted to an xs:double. #### 4.5.1 fn:number Summary Returns the value indicated by $value or, if $value is not specified, the context item after atomization, converted to an xs:double. Signatures  fn:number() as xs:double  fn:number( $value as xs:anyAtomicType? := . ) as xs:double
Properties

The zero-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-dependent·.

The one-argument form of this function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

Calling the zero-argument version of the function is defined to give the same result as calling the single-argument version with the context item (.). That is, fn:number() is equivalent to fn:number(.), as defined by the rules that follow.

If $value is the empty sequence or if $value cannot be converted to an xs:double, the xs:double value NaN is returned.

Otherwise, $value is converted to an xs:double following the rules of 19.1.2.2 Casting to xs:double. If the conversion to xs:double fails, the xs:double value NaN is returned. Error Conditions A dynamic error is raised [err:XPDY0002]XP if $value is omitted and the context item is absentDM40.

As a consequence of the rules given above, a type error occurs if the context item cannot be atomized, or if the result of atomizing the context item is a sequence containing more than one atomic value.

Notes

XSD 1.1 allows the string +INF as a representation of positive infinity; XSD 1.0 does not. It is ·implementation-defined· whether XSD 1.1 is supported.

Generally fn:number returns NaN rather than raising a dynamic error if the argument cannot be converted to xs:double. However, a type error is raised in the usual way if the supplied argument cannot be atomized or if the result of atomization does not match the required argument type.

Examples

The expression fn:number($item1/quantity) returns 5.0e0. The expression fn:number($item2/description) returns xs:double('NaN').

Assume that the context item is the xs:string value "15". Then fn:number() returns 1.5e1.

### 4.6 Formatting integers

Function Meaning
fn:format-integer Formats an integer according to a given picture string, using the conventions of a given natural language if specified.

#### 4.6.1 fn:format-integer

Summary

Formats an integer according to a given picture string, using the conventions of a given natural language if specified.

Signatures
 fn:format-integer( $value as xs:integer?, $picture as xs:string ) as xs:string
 fn:format-integer( $value as xs:integer?, $picture as xs:string, $lang as xs:string? ) as xs:string Properties The two-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on default language. The three-argument form of this function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is an empty sequence, the function returns a zero-length string.

In all other cases, the $picture argument describes the format in which $value is output.

The rules that follow describe how non-negative numbers are output. If the value of $value is negative, the rules below are applied to the absolute value of $value, and a minus sign is prepended to the result.

The value of $picture consists of a primary format token, optionally followed by a format modifier. The primary format token is always present and must not be zero-length. If the string contains one or more semicolons then everything that precedes the last semicolon is taken as the primary format token and everything that follows is taken as the format modifier; if the string contains no semicolon then the entire picture is taken as the primary format token, and the format modifier is taken to be absent (which is equivalent to supplying a zero-length string). The primary format token is classified as one of the following: 1. A decimal-digit-pattern made up of optional-digit-signs, mandatory-digit-signs, and grouping-separator-signs. • The optional-digit-sign is the character "#". • A mandatory-digit-sign is a ·character· in Unicode category Nd. All mandatory-digit-signs within the format token must be from the same digit family, where a digit family is a sequence of ten consecutive characters in Unicode category Nd, having digit values 0 through 9. Within the format token, these digits are interchangeable: a three-digit number may thus be indicated equivalently by 000, 001, or 999. • a grouping-separator-sign is a non-alphanumeric character, that is a ·character· whose Unicode category is other than Nd, Nl, No, Lu, Ll, Lt, Lm or Lo. If the primary format token contains at least one Unicode digit then it is taken as a decimal digit pattern, and in this case it must match the regular expression ^((\p{Nd}|#|[^\p{N}\p{L}])+?)$. If it contains a digit but does not match this pattern, a dynamic error is raised [err:FODF1310].

Note:

If a semicolon is to be used as a grouping separator, then the primary format token as a whole must be followed by another semicolon, to ensure that the grouping separator is not mistaken as a separator between the primary format token and the format modifier.

There must be at least one mandatory-digit-sign. There may be zero or more optional-digit-signs, and (if present) these must precede all mandatory-digit-signs. There may be zero or more grouping-separator-signs. A grouping-separator-sign must not appear at the start or end of the decimal-digit-pattern, nor adjacent to another grouping-separator-sign.

The corresponding output format is a decimal number, using this digit family, with at least as many digits as there are mandatory-digit-signs in the format token. Thus, a format token 1 generates the sequence 0 1 2 ... 10 11 12 ..., and a format token 01 (or equivalently, 00 or 99) generates the sequence 00 01 02 ... 09 10 11 12 ... 99 100 101. A format token of &#x661; (Arabic-Indic digit one) generates the sequence ١ then ٢ then ٣ ...

The grouping-separator-signs are handled as follows:

1. The position of grouping separators within the format token, counting backwards from the last digit, indicates the position of grouping separators to appear within the formatted number, and the character used as the grouping-separator-sign within the format token indicates the character to be used as the corresponding grouping separator in the formatted number.

2. More specifically, the position of a grouping separator is the number of optional-digit-signs and mandatory-digit-signs appearing between the grouping separator and the right-hand end of the primary format token.

3. Grouping separators are defined to be regular if the following conditions apply:

1. There is at least one grouping separator.

2. Every grouping separator is the same character (call it C).

3. There is a positive integer G (the grouping size) such that:

1. The position of every grouping separator is an integer multiple of G, and

2. Every positive integer multiple of G that is less than the number of optional-digit-signs and mandatory-digit-signs in the primary format token is the position of a grouping separator.

4. The grouping separator template is a (possibly infinite) set of (position, character) pairs.

5. If grouping separators are regular, then the grouping separator template contains one pair of the form (n×G, C) for every positive integer n where G is the grouping size and C is the grouping character.

6. Otherwise (when grouping separators are not regular), the grouping separator template contains one pair of the form (P, C) for every grouping separator found in the primary formatting token, where C is the grouping separator character and P is its position.

7. Note:

If there are no grouping separators, then the grouping separator template is an empty set.

The number is formatted as follows:

1. Let S1 be the result of formatting the supplied number in decimal notation as if by casting it to xs:string.

2. Let S2 be the result of padding S1 on the left with as many leading zeroes as are needed to ensure that it contains at least as many digits as the number of mandatory-digit-signs in the primary format token.

3. Let S3 be the result of replacing all decimal digits (0-9) in S2 with the corresponding digits from the selected digit family.

4. Let S4 be the result of inserting grouping separators into S3: for every (position P, character C) pair in the grouping separator template where P is less than the number of digits in S3, insert character C into S3 at position P, counting from the right-hand end.

5. Let S5 be the result of converting S4 into ordinal form, if an ordinal modifier is present, as described below.

6. The result of the function is then S5.

2. The format token A, which generates the sequence A B C ... Z AA AB AC....

3. The format token a, which generates the sequence a b c ... z aa ab ac....

4. The format token i, which generates the sequence i ii iii iv v vi vii viii ix x ....

5. The format token I, which generates the sequence I II III IV V VI VII VIII IX X ....

6. The format token w, which generates numbers written as lower-case words, for example in English, one two three four ...

7. The format token W, which generates numbers written as upper-case words, for example in English, ONE TWO THREE FOUR ...

8. The format token Ww, which generates numbers written as title-case words, for example in English, One Two Three Four ...

9. Any other format token, which indicates a numbering sequence in which that token represents the number 1 (one) (but see the note below). It is ·implementation-defined· which numbering sequences, additional to those listed above, are supported. If an implementation does not support a numbering sequence represented by the given token, it must use a format token of 1.

Note:

In some traditional numbering sequences additional signs are added to denote that the letters should be interpreted as numbers; these are not included in the format token. An example (see also the example below) is classical Greek where a dexia keraia (x0374, ʹ) and sometimes an aristeri keraia (x0375, ͵) is added.

For all format tokens other than a decimal-digit-pattern, there may be ·implementation-defined· lower and upper bounds on the range of numbers that can be formatted using this format token; indeed, for some numbering sequences there may be intrinsic limits. For example, the format token &#x2460; (circled digit one, ①) has a range imposed by the Unicode character repertoire — zero to 20 in Unicode versions prior to 3.2, or zero to 50 in subsequent versions. For the numbering sequences described above any upper bound imposed by the implementation must not be less than 1000 (one thousand) and any lower bound must not be greater than 1. Numbers that fall outside this range must be formatted using the format token 1.

The above expansions of numbering sequences for format tokens such as a and i are indicative but not prescriptive. There are various conventions in use for how alphabetic sequences continue when the alphabet is exhausted, and differing conventions for how roman numerals are written (for example, IV versus IIII as the representation of the number 4). Sometimes alphabetic sequences are used that omit letters such as i and o. This specification does not prescribe the detail of any sequence other than those sequences consisting entirely of decimal digits.

Many numbering sequences are language-sensitive. This applies especially to the sequence selected by the tokens w, W and Ww. It also applies to other sequences, for example different languages using the Cyrillic alphabet use different sequences of characters, each starting with the letter #x410 (Cyrillic capital letter A). In such cases, the $lang argument specifies which language's conventions are to be used. If the argument is specified, the value should be either an empty sequence or a value that would be valid for the xml:lang attribute (see [Extensible Markup Language (XML) 1.0 (Fifth Edition)]). Note that this permits the identification of sublanguages based on country codes (from ISO 3166-1) as well as identification of dialects and regions within a country. The set of languages for which numbering is supported is ·implementation-defined·. If the $lang argument is absent, or is set to an empty sequence, or is invalid, or is not a language supported by the implementation, then the number is formatted using the default language from the dynamic context.

The format modifier must be a string that matches the regular expression ^([co]($$.+$$)?)?[at]?$. That is, if it is present it must consist of one or more of the following, in order: • either c or o, optionally followed by a sequence of characters enclosed between parentheses, to indicate cardinal or ordinal numbering respectively, the default being cardinal numbering • either a or t, to indicate alphabetic or traditional numbering respectively, the default being ·implementation-defined·. If the o modifier is present, this indicates a request to output ordinal numbers rather than cardinal numbers. For example, in English, when used with the format token 1, this outputs the sequence 1st 2nd 3rd 4th ..., and when used with the format token w outputs the sequence first second third fourth .... The string of characters between the parentheses, if present, is used to select between other possible variations of cardinal or ordinal numbering sequences. The interpretation of this string is ·implementation-defined·. No error occurs if the implementation does not define any interpretation for the defined string. It is ·implementation-defined· what combinations of values of the format token, the language, and the cardinal/ordinal modifier are supported. If ordinal numbering is not supported for the combination of the format token, the language, and the string appearing in parentheses, the request is ignored and cardinal numbers are generated instead. The use of the a or t modifier disambiguates between numbering sequences that use letters. In many languages there are two commonly used numbering sequences that use letters. One numbering sequence assigns numeric values to letters in alphabetic sequence, and the other assigns numeric values to each letter in some other manner traditional in that language. In English, these would correspond to the numbering sequences specified by the format tokens a and i. In some languages, the first member of each sequence is the same, and so the format token alone would be ambiguous. In the absence of the a or t modifier, the default is ·implementation-defined·. Error Conditions A dynamic error is raised [err:FODF1310] if the format token is invalid, that is, if it violates any mandatory rules (indicated by an emphasized must or required keyword in the above rules). For example, the error is raised if the primary format token contains a digit but does not match the required regular expression. Notes 1. Note the careful distinction between conditions that are errors and conditions where fallback occurs. The principle is that an error in the syntax of the format picture will be reported by all processors, while a construct that is recognized by some implementations but not others will never result in an error, but will instead cause a fallback representation of the integer to be used. 2. The following notes apply when a decimal-digit-pattern is used: 1. If grouping-separator-signs appear at regular intervals within the format token, then the sequence is extrapolated to the left, so grouping separators will be used in the formatted number at every multiple of N. For example, if the format token is 0'000 then the number one million will be formatted as 1'000'000, while the number fifteen will be formatted as 0'015. 2. The only purpose of optional-digit-signs is to mark the position of grouping-separator-signs. For example, if the format token is #'##0 then the number one million will be formatted as 1'000'000, while the number fifteen will be formatted as 15. A grouping separator is included in the formatted number only if there is a digit to its left, which will only be the case if either (a) the number is large enough to require that digit, or (b) the number of mandatory-digit-signs in the format token requires insignificant leading zeros to be present. 3. Grouping separators are not designed for effects such as formatting a US telephone number as (365)123-9876. In general they are not suitable for such purposes because (a) only single characters are allowed, and (b) they cannot appear at the beginning or end of the number. 4. Numbers will never be truncated. Given the decimal-digit-pattern 01, the number three hundred will be output as 300, despite the absence of any optional-digit-sign. 3. The following notes apply when ordinal numbering is selected using the o modifier. In some languages, the form of numbers (especially ordinal numbers) varies depending on the grammatical context: they may have different genders and may decline with the noun that they qualify. In such cases the string appearing in parentheses after the letter c or o may be used to indicate the variation of the cardinal or ordinal number required. The way in which the variation is indicated will depend on the conventions of the language. For inflected languages that vary the ending of the word, the approach recommended in the previous version of this specification was to indicate the required ending, preceded by a hyphen: for example in German, appropriate values might be o(-e), o(-er), o(-es), o(-en). Another approach, which might usefully be adopted by an implementation based on the open-source ICU localization library [ICU], or any other library making use of the Unicode Common Locale Data Repository [Unicode CLDR], is to allow the value in parentheses to be the name of a registered numbering rule set for the language in question, conventionally prefixed with a percent sign: for example, o(%spellout-ordinal-masculine), or c(%spellout-cardinal-year). Examples The expression format-integer(123, '0000') returns "0123". format-integer(123, 'w') might return "one hundred and twenty-three" Ordinal numbering in Italian: The specification "1;o(-º)" with $lang equal to it, if supported, should produce the sequence:

1º 2º 3º 4º ...

The specification "Ww;o" with $lang equal to it, if supported, should produce the sequence: Primo Secondo Terzo Quarto Quinto ... The expression format-integer(21, '1;o', 'en') returns "21st". format-integer(14, 'Ww;o(-e)', 'de') might return "Vierzehnte" The expression format-integer(7, 'a') returns "g". The expression format-integer(57, 'I') returns "LVII". The expression format-integer(1234, '#;##0;') returns "1;234". ### 4.7 Formatting numbers This section defines a function for formatting decimal and floating point numbers. Function Meaning fn:format-number Returns a string containing a number formatted according to a given picture string, taking account of decimal formats specified in the static context. Note: This function can be used to format any numeric quantity, including an integer. For integers, however, the fn:format-integer function offers additional possibilities. Note also that the picture strings used by the two functions are not 100% compatible, though they share some options in common. #### 4.7.1 Defining a decimal format Decimal formats are defined in the static context, and the way they are defined is therefore outside the scope of this specification. XSLT and XQuery both provide custom syntax for creating a decimal format. The static context provides a set of decimal formats. One of the decimal formats is unnamed, the others (if any) are identified by a QName. There is always an unnamed decimal format available, but its contents are ·implementation-defined·. Each decimal format provides a set of named properties, described in the following table: Name Type Usage (non-normative) decimal-separator A single ·character· Defines the character used to represent the decimal point (typically ".") both in the picture string and in the formatted number. grouping-separator A single ·character· Defines the character used to separate groups of digits (typically ",") both in the picture string and in the formatted number. exponent-separator A single ·character· Defines the character used to separate the mantissa from the exponent in scientific notation (typically "e") both in the picture string and in the formatted number. infinity A ·string· Defines the string used to represent the value positive or negative infinity in the formatted number (typically "Infinity") minus-sign A single ·character· Defines the character used as a minus sign in the formatted number if there is no subpicture for formatting negative numbers (typically "-", x2D) NaN A ·string· Defines the string used to represent the value NaN in the formatted number percent A single ·character· Defines the character used as a percent sign (typically "%") both in the picture string and in the formatted number per-mille A single ·character· Defines the character used as a per-mille sign (typically "‰", x2030) both in the picture string and in the formatted number zero-digit A single ·character·, which must be a character in Unicode category Nd with decimal digit value 0 (zero) Defines the characters used in the picture string to represent a mandatory digit: for example, if the zero-digit is "0" then any of the digits "0" to "9" may be used (interchangeably) in the picture string to represent a mandatory digit, and in the formatted number the characters "0" to "9" will be used to represent the digits zero to nine. digit A single ·character· Defines the character used in the picture string to represent an optional digit (typically "#") pattern-separator A single ·character· Defines the character used in the picture string to separate the positive and negative subpictures (typically ";") Note: A phrase such as "The minus-signXP31 character" is to be read as "the character assigned to the minus-signXP31 property in the relevant decimal format within the static context". [Definition] The decimal digit family of a decimal format is the sequence of ten digits with consecutive Unicode ·codepoints· starting with the character that is the value of the zero-digitXP31 property. [Definition] The optional digit character is the character that is the value of the digitXP31 property. For any named or unnamed decimal format, the properties representing characters used in a ·picture string· must have distinct values. These properties are decimal-separatorXP31 , grouping-separatorXP31, exponent-separatorXP31, percentXP31, per-milleXP31, digitXP31, and pattern-separatorXP31. Furthermore, none of these properties may be equal to any ·character· in the ·decimal digit family·. #### 4.7.2 fn:format-number Summary Returns a string containing a number formatted according to a given picture string, taking account of decimal formats specified in the static context. Signatures  fn:format-number( $value as xs:numeric?, $picture as xs:string ) as xs:string  fn:format-number( $value as xs:numeric?, $picture as xs:string, $decimal-format-name as union(xs:string, xs:QName)? ) as xs:string
Properties

The two-argument form of this function is ·deterministic·, ·context-independent·, and ·focus-independent·.

The three-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on decimal formats, and namespaces.

Rules

The effect of the two-argument form of the function is equivalent to calling the three-argument form with an empty sequence as the value of the third argument.

The function formats $value as a string using the ·picture string· specified by the $picture argument and the decimal-format named by the $decimal-format-name argument, or the unnamed decimal-format, if there is no $decimal-format-name argument. The syntax of the picture string is described in 4.7.3 Syntax of the picture string.

The $value argument may be of any numeric data type (xs:double, xs:float, xs:decimal, or their subtypes including xs:integer). Note that if an xs:decimal is supplied, it is not automatically promoted to an xs:double, as such promotion can involve a loss of precision. If the supplied value of the $value argument is an empty sequence, the function behaves as if the supplied value were the xs:double value NaN.

The value of $decimal-format-name, if present and non-empty, must be either an xs:QName, or a string which after removal of leading and trailing whitespace is in the form of an EQName as defined in the XPath 4.0 grammar, that is one of the following: • A lexical QName, which is expanded using the statically known namespaces. The default namespace is not used (no prefix means no namespace). • A URIQualifiedName using the syntax Q{uri}local, where the URI can be zero-length to indicate a name in no namespace. The decimal format that is used is the decimal format in the static context whose name matches $decimal-format-name if supplied, or the unnamed decimal format in the static context otherwise.

The evaluation of the fn:format-number function takes place in two phases, an analysis phase described in 4.7.4 Analyzing the picture string and a formatting phase described in 4.7.5 Formatting the number.

The analysis phase takes as its inputs the ·picture string· and the variables derived from the relevant decimal format in the static context, and produces as its output a number of variables with defined values. The formatting phase takes as its inputs the number to be formatted and the variables produced by the analysis phase, and produces as its output a string containing a formatted representation of the number.

The result of the function is the formatted string representation of the supplied number.

Error Conditions

A dynamic error is raised [err:FODF1280] if the decimal-format-name argument is supplied as an xs:string that is neither a valid lexical QName nor a valid URIQualifiedName, or if it uses a prefix that is not found in the statically known namespaces, or if the static context does not contain a declaration of a decimal-format with a matching expanded QName. If the processor is able to detect the error statically (for example, when the argument is supplied as a string literal), then the processor may optionally signal this as a static error. Notes A string is an ordered sequence of characters, and this specification uses terms such as "left" and "right", "preceding" and "following" in relation to this ordering, irrespective of the position of the characters when visually rendered on some output medium. Both in the picture string and in the result string, digits with higher significance (that is, representing higher powers of ten) always precede digits with lower significance, even when the rendered text flow is from right to left. Examples The following examples assume a default decimal format in which the chosen digits are the ASCII digits 0-9, the decimal separator is ".", the grouping separator is ",", the minus-sign is "-", and the percent-sign is "%". The expression format-number(12345.6, '#,###.00') returns "12,345.60". The expression format-number(12345678.9, '9,999.99') returns "12,345,678.90". The expression format-number(123.9, '9999') returns "0124". The expression format-number(0.14, '01%') returns "14%". The expression format-number(-6, '000') returns "-006". The following example assumes the existence of a decimal format named 'ch' in which the grouping separator is ʹ and the decimal separator is ·: The expression format-number(1234.5678, '#ʹ##0·00', 'ch') returns "1ʹ234·57". The following examples assume that the exponent separator is in decimal format 'fortran' is 'E': The expression format-number(1234.5678, '00.000E0', 'fortran') returns "12.346E2". The expression format-number(0.234, '0.0E0', 'fortran') returns "2.3E-1". The expression format-number(0.234, '#.00E0', 'fortran') returns "0.23E0". The expression format-number(0.234, '.00E0', 'fortran') returns ".23E0". #### 4.7.3 Syntax of the picture string Note: This differs from the format-number function previously defined in XSLT 2.0 in that any digit can be used in the picture string to represent a mandatory digit: for example the picture strings '000', '001', and '999' are equivalent. The digits will all be from the same decimal digit family, specifically, the sequence of ten consecutive digits starting with the digit assigned to the zero-digit property. This change is to align format-number (which previously used '000') with format-dateTime (which used '001'). [Definition] The formatting of a number is controlled by a picture string. The picture string is a sequence of ·characters·, in which the characters assigned to the properties decimal-separatorXP31 , exponent-separatorXP31, grouping-separatorXP31, and digitXP31, and pattern-separatorXP31 and the members of the ·decimal digit family·, are classified as active characters, and all other characters (including the values of the properties percentXP31 and per-milleXP31) are classified as passive characters. A dynamic error is raised [err:FODF1310] if the ·picture string· does not conform to the following rules. Note that in these rules the words "preceded" and "followed" refer to characters anywhere in the string, they are not to be read as "immediately preceded" and "immediately followed". • A picture-string consists either of a sub-picture, or of two sub-pictures separated by the pattern-separatorXP31 character. A picture-string must not contain more than one instance of the pattern-separatorXP31 character. If the picture-string contains two sub-pictures, the first is used for positive and unsigned zero values and the second for negative values. • A sub-picture must not contain more than one instance of the decimal-separatorXP31 character. • A sub-picture must not contain more than one instance of the percentXP31 or per-milleXP31 characters, and it must not contain one of each. • The mantissa part of a sub-picture (defined below) must contain at least one character that is either an ·optional digit character· or a member of the ·decimal digit family·. • A sub-picture must not contain a passive character that is preceded by an active character and that is followed by another active character. • A sub-picture must not contain a grouping-separatorXP31 character that appears adjacent to a decimal-separatorXP31 character, or in the absence of a decimal-separatorXP31 character, at the end of the integer part. • A sub-picture must not contain two adjacent instances of the grouping-separatorXP31 character. • The integer part of a sub-picture (defined below) must not contain a member of the ·decimal digit family· that is followed by an instance of the ·optional digit character·. The fractional part of a sub-picture (defined below) must not contain an instance of the ·optional digit character· that is followed by a member of the ·decimal digit family·. • A character that matches the exponent-separatorXP31 property is treated as an exponent-separator-sign if it is both preceded and followed within the sub-picture by an active character. Otherwise, it is treated as a passive character. A sub-picture must not contain more than one character that is treated as an exponent-separator-sign. • A sub-picture that contains a percentXP31 or per-milleXP31 character must not contain a character treated as an exponent-separator-sign. • If a sub-picture contains a character treated as an exponent-separator-sign then this must be followed by one or more characters that are members of the ·decimal digit family·, and it must not be followed by any active character that is not a member of the ·decimal digit family·. The mantissa part of the sub-picture is defined as the part that appears to the left of the exponent-separator-sign if there is one, or the entire sub-picture otherwise. The exponent part of the subpicture is defined as the part that appears to the right of the exponent-separator-sign; if there is no exponent-separator-sign then the exponent part is absent. The integer part of the sub-picture is defined as the part that appears to the left of the decimal-separatorXP31 character if there is one, or the entire mantissa part otherwise. The fractional part of the sub-picture is defined as that part of the mantissa part that appears to the right of the decimal-separatorXP31 character if there is one, or the part that appears to the right of the rightmost active character otherwise. The fractional part may be zero-length. #### 4.7.4 Analyzing the picture string This phase of the algorithm analyzes the ·picture string· and the properties from the selected decimal format in the static context, and it has the effect of setting the values of various variables, which are used in the subsequent formatting phase. These variables are listed below. Each is shown with its initial setting and its datatype. Several variables are associated with each sub-picture. If there are two sub-pictures, then these rules are applied to one sub-picture to obtain the values that apply to positive and unsigned zero numbers, and to the other to obtain the values that apply to negative numbers. If there is only one sub-picture, then the values for both cases are derived from this sub-picture. The variables are as follows: • The integer-part-grouping-positions is a sequence of integers representing the positions of grouping separators within the integer part of the sub-picture. For each grouping-separatorXP31 character that appears within the integer part of the sub-picture, this sequence contains an integer that is equal to the total number of ·optional digit character· and ·decimal digit family· characters that appear within the integer part of the sub-picture and to the right of the grouping-separatorXP31 character. The grouping is defined to be regular if the following conditions apply: 1. There is an least one grouping-separator in the integer part of the sub-picture. 2. There is a positive integer G (the grouping size) such that the position of every grouping-separator in the integer part of the sub-picture is a positive integer multiple of G. 3. Every position in the integer part of the sub-picture that is a positive integer multiple of G is occupied by a grouping-separator. If the grouping is regular, then the integer-part-grouping-positions sequence contains all integer multiples of G as far as necessary to accommodate the largest possible number. • The minimum-integer-part-size is an integer indicating the minimum number of digits that will appear to the left of the decimal-separator character. It is initially set to the number of ·decimal digit family· characters found in the integer part of the sub-picture, but may be adjusted as described below. Note: There is no maximum integer part size. All significant digits in the integer part of the number will be displayed, even if this exceeds the number of ·optional digit character· and ·decimal digit family· characters in the subpicture. • The scaling factor is a non-negative integer used to determine the scaling of the mantissa in exponential notation. It is set to the number of ·decimal digit family· characters found in the integer part of the sub-picture. • The prefix is set to contain all passive characters in the sub-picture to the left of the leftmost active character. If the picture string contains only one sub-picture, the prefix for the negative sub-picture is set by concatenating the minus-signXP31 character and the prefix for the positive sub-picture (if any), in that order. • The fractional-part-grouping-positions is a sequence of integers representing the positions of grouping separators within the fractional part of the sub-picture. For each grouping-separatorXP31 character that appears within the fractional part of the sub-picture, this sequence contains an integer that is equal to the total number of ·optional digit character· and ·decimal digit family· characters that appear within the fractional part of the sub-picture and to the left of the grouping-separatorXP31 character. Note: There is no need to extrapolate grouping positions on the fractional side, because the number of digits in the output will never exceed the number of ·optional digit character· and ·decimal digit family· characters in the fractional part of the sub-picture. • The minimum-fractional-part-size is set to the number of ·decimal digit family· characters found in the fractional part of the sub-picture. • The maximum-fractional-part-size is set to the total number of ·optional digit character· and ·decimal digit family· characters found in the fractional part of the sub-picture. • If the effect of the above rules is that minimum-integer-part-size and maximum-fractional-part-size are both zero, then an adjustment is applied as follows: • If an exponent separator is present then: • minimum-fractional-part-size is changed to 1 (one). • maximum-fractional-part-size is changed to 1 (one). Note: This has the effect that with the picture #.e9, the value 0.123 is formatted as 0.1e0 • Otherwise: • minimum-integer-part-size is changed to 1 (one). Note: This has the effect that with the picture #, the value 0.23 is formatted as 0 • If all the following conditions are true: • An exponent separator is present • The minimum-integer-part-size is zero • There is at least one ·optional digit character· in the integer part of the sub-picture then the minimum-integer-part-size is changed to 1 (one). Note: This has the effect that with the picture .9e9, the value 0.1 is formatted as .1e0, while with the picture #.9e9, it is formatted as 0.1e0 • If (after making the above adjustments) the minimum-integer-part-size and the minimum-fractional-part-size are both zero, then the minimum-fractional-part-size is set to 1 (one). • The minimum-exponent-size is set to the number of ·decimal digit family· characters found in the exponent part of the sub-picture if present, or zero otherwise. Note: The rules for the syntax of the picture string ensure that if an exponent separator is present, then the minimum-exponent-size will always be greater than zero. • The suffix is set to contain all passive characters to the right of the rightmost active character in the sub-picture. Note: If there is only one sub-picture, then all variables for positive numbers and negative numbers will be the same, except for prefix: the prefix for negative numbers will be preceded by the minus-signXP31 character. #### 4.7.5 Formatting the number This section describes the second phase of processing of the fn:format-number function. This phase takes as input a number to be formatted (referred to as the input number), and the variables set up by analyzing the decimal format in the static context and the ·picture string·, as described above. The result of this phase is a string, which forms the return value of the fn:format-number function. The algorithm for this second stage of processing is as follows: 1. If the input number is NaN (not a number), the result is the value of the pattern separatorXP31 property (with no prefix or suffix). 2. In the rules below, the positive sub-picture and its associated variables are used if the input number is positive, and the negative sub-picture and its associated variables are used if it is negative. For xs:double and xs:float, negative zero is taken as negative, positive zero as positive. For xs:decimal and xs:integer, the positive sub-picture is used for zero. 3. The adjusted number is determined as follows: • If the sub-picture contains a percentXP31 character, the adjusted number is the input number multiplied by 100. • If the sub-picture contains a per-milleXP31 character, the adjusted number is the input number multiplied by 1000. • Otherwise, the adjusted number is the input number. If the multiplication causes numeric overflow, no error occurs, and the adjusted number is positive or negative infinity as appropriate. 4. If the adjusted number is positive or negative infinity, the result is the concatenation of the appropriate prefix, the value of the infinityXP31 property, and the appropriate suffix. 5. If the minimum exponent size is non-zero, and the adjusted number is non-zero, then the adjusted number is scaled to establish a mantissa and an integer exponent. The mantissa and exponent are chosen such that all the following conditions are true: • The primitive type of the mantissa is the same as the primitive type of the adjusted number (integer, decimal, float, or double). • The mantissa multiplied by ten to the power of the exponent is equal to the adjusted number. • The mantissa (unless it is zero) is less than 10N, and at least 10N-1, where N is the scaling factor. If the minimum exponent size is zero, then the mantissa is the adjusted number and there is no exponent. If the minimum exponent size is non-zero and the adjusted number is zero, then the mantissa is the adjusted number and the exponent is zero. 6. The mantissa is converted (if necessary) to an xs:decimal value, using an implementation of xs:decimal that imposes no limits on the totalDigits or fractionDigits facets. If there are several such values that are numerically equal to the mantissa (bearing in mind that if the mantissa is an xs:double or xs:float, the comparison will be done by converting the decimal value back to an xs:double or xs:float), the one that is chosen should be one with the smallest possible number of digits not counting leading or trailing zeroes (whether significant or insignificant). For example, 1.0 is preferred to 0.9999999999, and 100000000 is preferred to 100000001. This value is then rounded so that it uses no more than maximum-fractional-part-size digits in its fractional part. The rounded number is defined to be the result of converting the mantissa to an xs:decimal value, as described above, and then calling the function fn:round-half-to-even with this converted number as the first argument and the maximum-fractional-part-size as the second argument, again with no limits on the totalDigits or fractionDigits in the result. 7. The absolute value of the rounded number is converted to a string in decimal notation, using the digits in the ·decimal digit family· to represent the ten decimal digits, and the decimal-separatorXP31 character to separate the integer part and the fractional part. This string must always contain a decimal-separatorXP31, and it must contain no leading zeroes and no trailing zeroes. The value zero will at this stage be represented by a decimal-separatorXP31 on its own. 8. If the number of digits to the left of the decimal-separatorXP31 character is less than minimum-integer-part-size, leading zero digitXP31 characters are added to pad out to that size. 9. If the number of digits to the right of the decimal-separatorXP31 character is less than minimum-fractional-part-size, trailing zero digitXP31 characters are added to pad out to that size. 10. For each integer N in the integer-part-grouping-positions list, a grouping-separatorXP31 character is inserted into the string immediately after that digit that appears in the integer part of the number and has N digits between it and the decimal-separatorXP31 character, if there is such a digit. 11. For each integer N in the fractional-part-grouping-positions list, a grouping-separatorXP31 character is inserted into the string immediately before that digit that appears in the fractional part of the number and has N digits between it and the decimal-separatorXP31 character, if there is such a digit. 12. If there is no decimal-separatorXP31 character in the sub-picture, or if there are no digits to the right of the decimal-separator character in the string, then the decimal-separator character is removed from the string (it will be the rightmost character in the string). 13. If an exponent exists, then the string produced from the mantissa as described above is extended with the following, in order: (a) the exponent-separatorXP31 character; (b) if the exponent is negative, the minus-signXP31 character; (c) the value of the exponent represented as a decimal integer, extended if necessary with leading zeroes to make it up to the minimum exponent size, using digits taken from the ·decimal digit family·. 14. The result of the function is the concatenation of the appropriate prefix, the string conversion of the number as obtained above, and the appropriate suffix. ### 4.8 Trigonometric and exponential functions The functions in this section perform trigonometric and other mathematical calculations on xs:double values. They are provided primarily for use in applications performing geometrical computation, for example when generating SVG graphics. Functions are provided to support the six most commonly used trigonometric calculations: sine, cosine and tangent, and their inverses arc sine, arc cosine, and arc tangent. Other functions such as secant, cosecant, and cotangent are not provided because they are easily computed in terms of these six. The functions in this section (with the exception of math:pi) are specified by reference to [IEEE 754-2008], where they appear as Recommended operations in section 9. IEEE defines these functions for a variety of floating point formats; this specification defines them only for xs:double values. The IEEE specification applies with the following caveats: 1. IEEE states that the preferred quantum is language-defined. In this specification, it is ·implementation-defined·. 2. IEEE states that certain functions should raise the inexact exception if the result is inexact. In this specification, this exception if it occurs does not result in an error. Any diagnostic information is outside the scope of this specification. 3. IEEE defines various rounding algorithms for inexact results, and states that the choice of rounding direction, and the mechanisms for influencing this choice, are language-defined. In this specification, the rounding direction and any mechanisms for influencing it are ·implementation-defined·. 4. Certain operations (such as taking the square root of a negative number) are defined in IEEE to signal the invalid operation exception and return a quiet NaN. In this specification, such operations return NaN and do not raise an error. The same policy applies to operations (such as taking the logarithm of zero) that raise a divide-by-zero exception. Any diagnostic information is outside the scope of this specification. 5. Operations whose mathematical result is greater than the largest finite xs:double value are defined in IEEE to signal the overflow exception; operations whose mathematical result is closer to zero than the smallest non-zero xs:double value are similarly defined in IEEE to signal the underflow exception. The treatment of these exceptions in this specification is defined in 4.2 Arithmetic operators on numeric values. Function Meaning math:pi Returns an approximation to the mathematical constant π. math:exp Returns the value of ex where x is the argument value. math:exp10 Returns the value of 10x, where x is the supplied argument value. math:log Returns the natural logarithm of the argument. math:log10 Returns the base-ten logarithm of the argument. math:pow Returns the result of raising the first argument to the power of the second. math:sqrt Returns the non-negative square root of the argument. math:sin Returns the sine of the argument. The argument is an angle in radians. math:cos Returns the cosine of the argument. The argument is an angle in radians. math:tan Returns the tangent of the argument. The argument is an angle in radians. math:asin Returns the arc sine of the argument. math:acos Returns the arc cosine of the argument. math:atan Returns the arc tangent of the argument. math:atan2 Returns the angle in radians subtended at the origin by the point on a plane with coordinates (x, y) and the positive x-axis. #### 4.8.1 math:pi Summary Returns an approximation to the mathematical constant π. Signature  math:pi() as xs:double Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules This function returns the xs:double value whose lexical representation is 3.141592653589793e0 Examples The expression 2*math:pi() returns 6.283185307179586e0. The expression 60 * (math:pi() div 180) converts an angle of 60 degrees to radians. #### 4.8.2 math:exp Summary Returns the value of ex where x is the argument value. Signature  math:exp( value as xs:double? ) as xs:double?
Properties

This function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

If $value is the empty sequence, the function returns the empty sequence. Otherwise the result is the mathematical constant e raised to the power of $value, as defined in the [IEEE 754-2008] specification of the exp function applied to 64-bit binary floating point values.

Notes

The treatment of overflow and underflow is defined in 4.2 Arithmetic operators on numeric values.

Examples

The expression math:exp(()) returns ().

The expression math:exp(0) returns 1.0e0.

The expression math:exp(1) returns 2.7182818284590455e0 (approximately).

The expression math:exp(2) returns 7.38905609893065e0.

The expression math:exp(-1) returns 0.36787944117144233e0.

The expression math:exp(math:pi()) returns 23.140692632779267e0.

The expression math:exp(xs:double('NaN')) returns xs:double('NaN').

The expression math:exp(xs:double('INF')) returns xs:double('INF').

The expression math:exp(xs:double('-INF')) returns 0.0e0.

#### 4.8.3 math:exp10

Summary

Returns the value of 10x, where x is the supplied argument value.

Signature
 math:exp10( $value as xs:double? ) as xs:double? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the empty sequence.

Otherwise the result is ten raised to the power of $value, as defined in the [IEEE 754-2008] specification of the exp10 function applied to 64-bit binary floating point values. Notes The treatment of overflow and underflow is defined in 4.2 Arithmetic operators on numeric values. Examples The expression math:exp10(()) returns (). The expression math:exp10(0) returns 1.0e0. The expression math:exp10(1) returns 1.0e1. The expression math:exp10(0.5) returns 3.1622776601683795e0. The expression math:exp10(-1) returns 1.0e-1. The expression math:exp10(xs:double('NaN')) returns xs:double('NaN'). The expression math:exp10(xs:double('INF')) returns xs:double('INF'). The expression math:exp10(xs:double('-INF')) returns 0.0e0. #### 4.8.4 math:log Summary Returns the natural logarithm of the argument. Signature  math:log( $value as xs:double? ) as xs:double?
Properties

This function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

If $value is the empty sequence, the function returns the empty sequence. Otherwise the result is the natural logarithm of $value, as defined in the [IEEE 754-2008] specification of the log function applied to 64-bit binary floating point values.

Notes

The treatment of divideByZero and invalidOperation exceptions is defined in 4.2 Arithmetic operators on numeric values. The effect is that if the argument is zero, the result is -INF, and if it is negative, the result is NaN.

Examples

The expression math:log(()) returns ().

The expression math:log(0) returns xs:double('-INF').

The expression math:log(math:exp(1)) returns 1.0e0.

The expression math:log(1.0e-3) returns -6.907755278982137e0.

The expression math:log(2) returns 0.6931471805599453e0.

The expression math:log(-1) returns xs:double('NaN').

The expression math:log(xs:double('NaN')) returns xs:double('NaN').

The expression math:log(xs:double('INF')) returns xs:double('INF').

The expression math:log(xs:double('-INF')) returns xs:double('NaN').

#### 4.8.5 math:log10

Summary

Returns the base-ten logarithm of the argument.

Signature
 math:log10( $value as xs:double? ) as xs:double? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the empty sequence.

Otherwise the result is the base-10 logarithm of $value, as defined in the [IEEE 754-2008] specification of the log10 function applied to 64-bit binary floating point values. Notes The treatment of divideByZero and invalidOperation exceptions is defined in 4.2 Arithmetic operators on numeric values. The effect is that if the argument is zero, the result is -INF, and if it is negative, the result is NaN. Examples The expression math:log10(()) returns (). The expression math:log10(0) returns xs:double('-INF'). The expression math:log10(1.0e3) returns 3.0e0. The expression math:log10(1.0e-3) returns -3.0e0. The expression math:log10(2) returns 0.3010299956639812e0. The expression math:log10(-1) returns xs:double('NaN'). The expression math:log10(xs:double('NaN')) returns xs:double('NaN'). The expression math:log10(xs:double('INF')) returns xs:double('INF'). The expression math:log10(xs:double('-INF')) returns xs:double('NaN'). #### 4.8.6 math:pow Summary Returns the result of raising the first argument to the power of the second. Signature  math:pow( $x as xs:double?, $y as xs:numeric ) as xs:double? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $x is the empty sequence, the function returns the empty sequence.

If $y is an instance of xs:integer, the result is $x raised to the power of $y as defined in the [IEEE 754-2008] specification of the pown function applied to a 64-bit binary floating point value and an integer. Otherwise $y is converted to an xs:double by numeric promotion, and the result is $x raised to the power of $y as defined in the [IEEE 754-2008] specification of the pow function applied to two 64-bit binary floating point values.

Notes

The treatment of the divideByZero and invalidOperation exceptions is defined in 4.2 Arithmetic operators on numeric values. Some of the consequences are illustrated in the examples below.

Examples

The expression math:pow((), 93.7) returns ().

The expression math:pow(2, 3) returns 8.0e0.

The expression math:pow(-2, 3) returns -8.0e0.

The expression math:pow(2, -3) returns 0.125e0.

The expression math:pow(-2, -3) returns -0.125e0.

The expression math:pow(2, 0) returns 1.0e0.

The expression math:pow(0, 0) returns 1.0e0.

The expression math:pow(xs:double('INF'), 0) returns 1.0e0.

The expression math:pow(xs:double('NaN'), 0) returns 1.0e0.

The expression math:pow(-math:pi(), 0) returns 1.0e0.

The expression math:pow(0e0, 3) returns 0.0e0.

The expression math:pow(0e0, 4) returns 0.0e0.

The expression math:pow(-0e0, 3) returns -0.0e0.

The expression math:pow(0, 4) returns 0.0e0.

The expression math:pow(0e0, -3) returns xs:double('INF').

The expression math:pow(0e0, -4) returns xs:double('INF').

The expression math:pow(-0e0, -3) returns xs:double('-INF').

The expression math:pow(0, -4) returns xs:double('INF').

The expression math:pow(16, 0.5e0) returns 4.0e0.

The expression math:pow(16, 0.25e0) returns 2.0e0.

The expression math:pow(0e0, -3.0e0) returns xs:double('INF').

The expression math:pow(-0e0, -3.0e0) returns xs:double('-INF'). (Odd-valued whole numbers are treated specially).

The expression math:pow(0e0, -3.1e0) returns xs:double('INF').

The expression math:pow(-0e0, -3.1e0) returns xs:double('INF').

The expression math:pow(0e0, 3.0e0) returns 0.0e0.

The expression math:pow(-0e0, 3.0e0) returns -0.0e0. (Odd-valued whole numbers are treated specially).

The expression math:pow(0e0, 3.1e0) returns 0.0e0.

The expression math:pow(-0e0, 3.1e0) returns 0.0e0.

The expression math:pow(-1, xs:double('INF')) returns 1.0e0.

The expression math:pow(-1, xs:double('-INF')) returns 1.0e0.

The expression math:pow(1, xs:double('INF')) returns 1.0e0.

The expression math:pow(1, xs:double('-INF')) returns 1.0e0.

The expression math:pow(1, xs:double('NaN')) returns 1.0e0.

The expression math:pow(-2.5e0, 2.0e0) returns 6.25e0.

The expression math:pow(-2.5e0, 2.00000001e0) returns xs:double('NaN').

#### 4.8.7 math:sqrt

Summary

Returns the non-negative square root of the argument.

Signature
 math:sqrt( $value as xs:double? ) as xs:double? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the empty sequence.

Otherwise the result is the mathematical non-negative square root of $value as defined in the [IEEE 754-2008] specification of the squareRoot function applied to 64-bit binary floating point values. Notes The treatment of the invalidOperation exception is defined in 4.2 Arithmetic operators on numeric values. The effect is that if the argument is less than zero, the result is NaN. If $value is positive or negative zero, positive infinity, or NaN, then the result is $value. (Negative zero is the only case where the result can have negative sign) Examples The expression math:sqrt(()) returns (). The expression math:sqrt(0.0e0) returns 0.0e0. The expression math:sqrt(-0.0e0) returns -0.0e0. The expression math:sqrt(1.0e6) returns 1.0e3. The expression math:sqrt(2.0e0) returns 1.4142135623730951e0. The expression math:sqrt(-2.0e0) returns xs:double('NaN'). The expression math:sqrt(xs:double('NaN')) returns xs:double('NaN'). The expression math:sqrt(xs:double('INF')) returns xs:double('INF'). The expression math:sqrt(xs:double('-INF')) returns xs:double('NaN'). #### 4.8.8 math:sin Summary Returns the sine of the argument. The argument is an angle in radians. Signature  math:sin( $radians as xs:double? ) as xs:double?
Properties

This function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

If $radians is the empty sequence, the function returns the empty sequence. Otherwise the result is the sine of $radians (which is treated as an angle in radians) as defined in the [IEEE 754-2008] specification of the sin function applied to 64-bit binary floating point values.

Notes

The treatment of the invalidOperation and underflow exceptions is defined in 4.2 Arithmetic operators on numeric values.

If $radians is positive or negative zero, the result is $radians.

If $radians is positive or negative infinity, or NaN, then the result is NaN. Otherwise the result is always in the range -1.0e0 to +1.0e0 Examples The expression math:sin(()) returns (). The expression math:sin(0) returns 0.0e0. The expression math:sin(-0.0e0) returns -0.0e0. The expression math:sin(math:pi() div 2) returns 1.0e0 (approximately). The expression math:sin(-math:pi() div 2) returns -1.0e0 (approximately). The expression math:sin(math:pi()) returns 0.0e0 (approximately). The expression math:sin(xs:double('NaN')) returns xs:double('NaN'). The expression math:sin(xs:double('INF')) returns xs:double('NaN'). The expression math:sin(xs:double('-INF')) returns xs:double('NaN'). #### 4.8.9 math:cos Summary Returns the cosine of the argument. The argument is an angle in radians. Signature  math:cos( $radians as xs:double? ) as xs:double?
Properties

This function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

If $radians is the empty sequence, the function returns the empty sequence. If $radians is positive or negative infinity, or NaN, then the result is NaN.

Otherwise the result is the cosine of $θ (which is treated as an angle in radians) as defined in the [IEEE 754-2008] specification of the cos function applied to 64-bit binary floating point values. Notes The treatment of the invalidOperation exception is defined in 4.2 Arithmetic operators on numeric values. If $radians is positive or negative zero, the result is $radians. If $radiansis positive or negative infinity, or NaN, then the result is NaN.

Otherwise the result is always in the range -1.0e0 to +1.0e0

Examples

The expression math:cos(()) returns ().

The expression math:cos(0) returns 1.0e0.

The expression math:cos(-0.0e0) returns 1.0e0.

The expression math:cos(math:pi() div 2) returns 0.0e0 (approximately).

The expression math:cos(-math:pi() div 2) returns 0.0e0 (approximately).

The expression math:cos(math:pi()) returns -1.0e0 (approximately).

The expression math:cos(xs:double('NaN')) returns xs:double('NaN').

The expression math:cos(xs:double('INF')) returns xs:double('NaN').

The expression math:cos(xs:double('-INF')) returns xs:double('NaN').

#### 4.8.10 math:tan

Summary

Returns the tangent of the argument. The argument is an angle in radians.

Signature
 math:tan( $radians as xs:double? ) as xs:double? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $radians is the empty sequence, the function returns the empty sequence.

Otherwise the result is the tangent of $radians (which is treated as an angle in radians) as defined in the [IEEE 754-2008] specification of the tan function applied to 64-bit binary floating point values. Notes The treatment of the invalidOperation and underflow exceptions is defined in 4.2 Arithmetic operators on numeric values. If $radians is positive or negative infinity, or NaN, then the result is NaN.

Examples

The expression math:tan(()) returns ().

The expression math:tan(0) returns 0.0e0.

The expression math:tan(-0.0e0) returns -0.0e0.

The expression math:tan(math:pi() div 4) returns 1.0e0 (approximately).

The expression math:tan(-math:pi() div 4) returns -1.0e0 (approximately).

The expression 1 div math:tan(math:pi() div 2) returns 0.0e0 (approximately). (Mathematically, tan(π/2) is positive infinity. But because math:pi() div 2 returns an approximation, the result of math:tan(math:pi() div 2) will be a large but finite number.)

The expression 1 div math:tan(-math:pi() div 2) returns -0.0e0 (approximately). (Mathematically, tan(-π/2) is negative infinity. But because -math:pi() div 2 returns an approximation, the result of math:tan(-math:pi() div 2) will be a large but finite negative number.)

The expression math:tan(math:pi()) returns 0.0e0 (approximately).

The expression math:tan(xs:double('NaN')) returns xs:double('NaN').

The expression math:tan(xs:double('INF')) returns xs:double('NaN').

The expression math:tan(xs:double('-INF')) returns xs:double('NaN').

#### 4.8.11 math:asin

Summary

Returns the arc sine of the argument.

Signature
 math:asin( $value as xs:double? ) as xs:double? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the empty sequence.

Otherwise the result is the arc sine of $value as defined in the [IEEE 754-2008] specification of the asin function applied to 64-bit binary floating point values. The result is in the range -π/2 to +π/2 radians. Notes The treatment of the invalidOperation and underflow exceptions is defined in 4.2 Arithmetic operators on numeric values. If $value is positive or negative zero, the result is $value. If $value is NaN, or if its absolute value is greater than one, then the result is NaN.

In other cases the result is an xs:double value representing an angle θ in radians in the range -π/2 <= θ <= +π/2.

Examples

The expression math:asin(()) returns ().

The expression math:asin(0) returns 0.0e0.

The expression math:asin(-0.0e0) returns -0.0e0.

The expression math:asin(1.0e0) returns 1.5707963267948966e0 (approximately).

The expression math:asin(-1.0e0) returns -1.5707963267948966e0 (approximately).

The expression math:asin(2.0e0) returns xs:double('NaN').

The expression math:asin(xs:double('NaN')) returns xs:double('NaN').

The expression math:asin(xs:double('INF')) returns xs:double('NaN').

The expression math:asin(xs:double('-INF')) returns xs:double('NaN').

#### 4.8.12 math:acos

Summary

Returns the arc cosine of the argument.

Signature
 math:acos( $value as xs:double? ) as xs:double? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the empty sequence.

Otherwise the result is the arc cosine of $value, as defined in the [IEEE 754-2008] specification of the acos function applied to 64-bit binary floating point values. The result is in the range zero to +π radians. Notes The treatment of the invalidOperation exception is defined in 4.2 Arithmetic operators on numeric values. If $value is NaN, or if its absolute value is greater than one, then the result is NaN.

In other cases the result is an xs:double value representing an angle θ in radians in the range 0 <= θ <= +π.

Examples

The expression math:acos(()) returns ().

The expression math:acos(0) returns 1.5707963267948966e0 (approximately).

The expression math:acos(-0.0e0) returns 1.5707963267948966e0 (approximately).

The expression math:acos(1.0e0) returns 0.0e0.

The expression math:acos(-1.0e0) returns 3.141592653589793e0 (approximately).

The expression math:acos(2.0e0) returns xs:double('NaN').

The expression math:acos(xs:double('NaN')) returns xs:double('NaN').

The expression math:acos(xs:double('INF')) returns xs:double('NaN').

The expression math:acos(xs:double('-INF')) returns xs:double('NaN').

#### 4.8.13 math:atan

Summary

Returns the arc tangent of the argument.

Signature
 math:atan( $value as xs:double? ) as xs:double? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the empty sequence.

Otherwise the result is the arc tangent of $value, as defined in the [IEEE 754-2008] specification of the atan function applied to 64-bit binary floating point values. The result is in the range -π/2 to +π/2 radians. Notes The treatment of the underflow exception is defined in 4.2 Arithmetic operators on numeric values. If $value is positive or negative zero, the result is $value. If $value is NaN then the result is NaN.

In other cases the result is an xs:double value representing an angle θ in radians in the range -π/2 <= θ <= +π/2.

Examples

The expression math:atan(()) returns ().

The expression math:atan(0) returns 0.0e0.

The expression math:atan(-0.0e0) returns -0.0e0.

The expression math:atan(1.0e0) returns 0.7853981633974483e0 (approximately).

The expression math:atan(-1.0e0) returns -0.7853981633974483e0 (approximately).

The expression math:atan(xs:double('NaN')) returns xs:double('NaN').

The expression math:atan(xs:double('INF')) returns 1.5707963267948966e0 (approximately).

The expression math:atan(xs:double('-INF')) returns -1.5707963267948966e0 (approximately).

#### 4.8.14 math:atan2

Summary

Returns the angle in radians subtended at the origin by the point on a plane with coordinates (x, y) and the positive x-axis.

Signature
 math:atan2( $y as xs:double, $x as xs:double ) as xs:double
Properties

This function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

The result is the value of atan2(y, x) as defined in the [IEEE 754-2008] specification of the atan2 function applied to 64-bit binary floating point values. The result is in the range -π to +π radians.

Notes

The treatment of the underflow exception is defined in 4.2 Arithmetic operators on numeric values. The following rules apply when the values are finite and non-zero, (subject to rules for overflow, underflow and approximation).

If either argument is NaN then the result is NaN.

If $x is positive, then the value of atan2($y, $x) is atan($y div $x). If $x is negative, then:

• If $y is positive, then the value of atan2($y, $x) is atan($y div $x) + π. • If $y is negative, then the value of atan2($y,$x) is atan($y div$x) - π.

Some results for special values of the arguments are shown in the examples below.

Examples

The expression math:atan2(+0.0e0, 0.0e0) returns 0.0e0.

The expression math:atan2(-0.0e0, 0.0e0) returns -0.0e0.

The expression math:atan2(+0.0e0, -0.0e0) returns 3.141592653589793e0.

The expression math:atan2(-0.0e0, -0.0e0) returns -3.141592653589793e0.

The expression math:atan2(-1, 0.0e0) returns -1.5707963267948966e0.

The expression math:atan2(+1, 0.0e0) returns 1.5707963267948966e0.

The expression math:atan2(-0.0e0, -1) returns -3.141592653589793e0.

The expression math:atan2(+0.0e0, -1) returns 3.141592653589793e0.

The expression math:atan2(-0.0e0, +1) returns -0.0e0.

The expression math:atan2(+0.0e0, +1) returns +0.0e0.

### 4.9 Random Numbers

Function Meaning
fn:random-number-generator Returns a random number generator, which can be used to generate sequences of random numbers.

#### 4.9.1 fn:random-number-generator

Summary

Returns a random number generator, which can be used to generate sequences of random numbers.

Signatures
 fn:random-number-generator() as item-type(rng)
 fn:random-number-generator( $seed as xs:anyAtomicType? ) as item-type(rng) Properties This function is ·deterministic·, ·context-independent·, ·focus-independent·, and ·higher-order·. Rules The function returns a random number generator. A random number generator is represented as a value of type rng, defined as follows: record( number as xs:double, next as (function() as record(number, next, permute, *)), permute as (function(item()*) as item()*), * ) That is, the result of the function is a map containing three entries. The keys of each entry are strings: 1. The entry with key "number" holds a random number; it is an xs:double greater than or equal to zero (0.0e0), and less than one (1.0e0). 2. The entry with key "next" is a zero-arity function that can be called to return another random number generator. The properties of this function are as follows: • name: absent • parameter names: () • signature: () => map(xs:string, item()) • non-local variable bindings: none • implementation: implementation-dependent 3. The entry with key "permute" is a function with arity 1 (one), which takes an arbitrary sequence as its argument, and returns a random permutation of that sequence. The properties of this function are as follows: • name: absent • parameter names: ("arg") • signature: (item()*) => item()* • non-local variable bindings: none • implementation: implementation-dependent Calling the fn:random-number-generator function with no arguments is equivalent to calling the single-argument form of the function with an implementation-dependent seed. Calling the fn:random-number-generator function with an empty sequence as $seed is equivalent to calling the single-argument form of the function with an implementation-dependent seed.

If a $seed is supplied, it may be an atomic value of any type. Both forms of the function are ·deterministic·: calling the function twice with the same arguments, within a single ·execution scope·, produces the same results. The value of the number entry should be such that all eligible xs:double values are equally likely to be chosen the distribution of numbers is uniform: for example, the probability of the number being in the range 0.1e0 to 0.2e0 is the same as the probability of its being in the range 0.8e0 to 0.9e0. The function returned in the permute entry should be such that all permutations of the supplied sequence are equally likely to be chosen. The map returned by the fn:random-number-generator function may contain additional entries beyond those specified here, but it must match the type item-type(rng) defined above. The meaning of any additional entries is ·implementation-defined·. To avoid conflict with any future version of this specification, the keys of any such entries should start with an underscore character. Notes It is not meaningful to ask whether the functions returned in the next and permute functions resulting from two separate calls with the same seed are "the same function", but the functions must be equivalent in the sense that calling them produces the same sequence of random numbers. The repeatability of the results of function calls in different execution scopes is outside the scope of this specification. It is recommended that when the same seed is provided explicitly, the same random number sequence should be delivered even in different execution scopes; while if no seed is provided, the processor should choose a seed that is likely to be different from one execution scope to another. (The same effect can be achieved explicitly by using fn:current-dateTime() as a seed.) The specification does not place strong conformance requirements on the actual randomness of the result; this is left to the implementation. It is desirable, for example, when generating a sequence of random numbers that the sequence should not get into a repeating loop; but the specification does not attempt to dictate this. Examples The following example returns a random permutation of the integers in the range 1 to 100: fn:random-number-generator()?permute(1 to 100) The following example returns a 10% sample of the items in an input sequence $seq, chosen at random: fn:random-number-generator()?permute($seq)[position() = 1 to (count($seq) idiv 10)]

The following code defines a function that can be called to produce a random sequence of xs:double values in the range zero to one, of specified length:

declare %public function r:random-sequence($length as xs:integer) as xs:double* { r:random-sequence($length, fn:random-number-generator())
};

declare %private function r:random-sequence($length as xs:integer,$G as record(number as xs:double, next as function(*), *)) {
if ($length eq 0) then () else ($G?number, r:random-sequence($length - 1,$G?next()))
};

r:random-sequence(200);


## 5 Functions on strings

This section specifies functions and operators on the [XML Schema Part 2: Datatypes Second Edition] xs:string datatype and the datatypes derived from it.

### 5.1 String types

The operators described in this section are defined on the following types. Each type whose name is indented is derived from the type whose name appears nearest above with one less level of indentation.

 xs:string xs:normalizedString xs:token xs:language xs:NMTOKEN xs:Name xs:NCName xs:ID xs:IDREF xs:ENTITY

They also apply to user-defined types derived by restriction from the above types.

### 5.2 Functions to assemble and disassemble strings

Function Meaning
fn:codepoints-to-string Returns an xs:string whose characters have supplied ·codepoints·.
fn:string-to-codepoints Returns the sequence of ·codepoints· that constitute an xs:string value.

#### 5.2.1 fn:codepoints-to-string

Summary

Returns an xs:string whose characters have supplied ·codepoints·.

Signature
 fn:codepoints-to-string( $values as xs:integer* ) as xs:string Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules The function returns the string made up from the ·characters· whose Unicode ·codepoints· are supplied in $values. This will be the zero-length string if $values is the empty sequence. Error Conditions A dynamic error is raised [err:FOCH0001] if any of the codepoints in $values is not a permitted XML character.

Examples

The expression fn:codepoints-to-string((66, 65, 67, 72)) returns "BACH".

The expression fn:codepoints-to-string((2309, 2358, 2378, 2325)) returns "अशॊक".

The expression fn:codepoints-to-string(()) returns "".

The expression fn:codepoints-to-string(0) raises error FOCH0001.

#### 5.2.2 fn:string-to-codepoints

Summary

Returns the sequence of ·codepoints· that constitute an xs:string value.

Signature
 fn:string-to-codepoints( $value as xs:string? ) as xs:integer* Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules The function returns a sequence of integers, each integer being the Unicode ·codepoint· of the corresponding ·character· in $value.

If $value is a zero-length string or the empty sequence, the function returns the empty sequence. Examples The expression fn:string-to-codepoints("Thérèse") returns (84, 104, 233, 114, 232, 115, 101). ### 5.3 Comparison of strings Function Meaning fn:compare Returns -1, 0, or 1, depending on whether $value1 collates before, equal to, or after $value2 according to the rules of a selected collation. fn:codepoint-equal Returns true if two strings are equal, considered codepoint-by-codepoint. fn:collation-key Given a string value and a collation, generates an internal value called a collation key, with the property that the matching and ordering of collation keys reflects the matching and ordering of strings under the specified collation. fn:contains-token Determines whether or not any of the supplied strings, when tokenized at whitespace boundaries, contains the supplied token, under the rules of the supplied collation. #### 5.3.1 Collations A collation is a specification of the manner in which ·strings· are compared and, by extension, ordered. When values whose type is xs:string or a type derived from xs:string are compared (or, equivalently, sorted), the comparisons are inherently performed according to some collation (even if that collation is defined entirely on codepoint values). The [Character Model for the World Wide Web 1.0: Fundamentals] observes that some applications may require different comparison and ordering behaviors than other applications. Similarly, some users having particular linguistic expectations may require different behaviors than other users. Consequently, the collation must be taken into account when comparing strings in any context. Several functions in this and the following section make use of a collation. Collations can indicate that two different codepoints are, in fact, equal for comparison purposes (e.g., "v" and "w" are considered equivalent in some Swedish collations). Strings can be compared codepoint-by-codepoint or in a linguistically appropriate manner, as defined by the collation. Some collations, especially those based on the Unicode Collation Algorithm (see [UTS #10]) can be "tailored" for various purposes. This document does not discuss such tailoring, nor does it provide a mechanism to perform tailoring. Instead, it assumes that the collation argument to the various functions below is a tailored and named collation. The ·Unicode codepoint collation· is a collation available in every implementation, which sorts based on codepoint values. For further details see 5.3.2 The Unicode Codepoint Collation. Collations may or may not perform Unicode normalization on strings before comparing them. This specification assumes that collations are named and that the collation name may be provided as an argument to string functions. Functions that allow specification of a collation do so with an argument whose type is xs:string but whose lexical form must conform to an xs:anyURI. If the collation is specified using a relative URI reference, it is resolved relative to the value of the static base URI property from the static context. This specification also defines the manner in which a default collation is determined if the collation argument is not specified in calls of functions that use a collation but allow it to be omitted. This specification does not define whether or not the collation URI is dereferenced. The collation URI may be an abstract identifier, or it may refer to an actual resource describing the collation. If it refers to a resource, this specification does not define the nature of that resource. One possible candidate is that the resource is a locale description expressed using the Locale Data Markup Language: see [UTS #35]. Functions such as fn:compare and fn:max that compare xs:string values use a single collation URI to identify all aspects of the collation rules. This means that any parameters such as the strength of the collation must be specified as part of the collation URI. For example, suppose there is a collation http://www.example.com/collations/French that refers to a French collation that compares on the basis of base characters. Collations that use the same basic rules, but with higher strengths, for example, base characters and accents, or base characters, accents and case, would need to be given different names, say http://www.example.com/collations/French1 and http://www.example.com/collations/French2. Note that some specifications use the term collation to refer to an algorithm that can be parameterized, but in this specification, each possible parameterization is considered to be a distinct collation. The XQuery/XPath static context includes a provision for a default collation that can be used for string comparisons and ordering operations. See the description of the static context in Section 2.1.1 Static Context XP31. If the default collation is not specified by the user or the system, the default collation is the ·Unicode codepoint collation·. Note: XML allows elements to specify the xml:lang attribute to indicate the language associated with the content of such an element. This specification does not use xml:lang to identify the default collation because using xml:lang does not produce desired effects when the two strings to be compared have different xml:lang values or when a string is multilingual. #### 5.3.2 The Unicode Codepoint Collation [Definition] The collation URI http://www.w3.org/2005/xpath-functions/collation/codepoint identifies a collation which must be recognized by every implementation: it is referred to as the Unicode codepoint collation (not to be confused with the Unicode collation algorithm). The Unicode codepoint collation does not perform any normalization on the supplied strings. The collation is defined as follows. Each of the two strings is converted to a sequence of integers using the fn:string-to-codepoints function. These two sequences $A and $B are then compared as follows: • If both sequences are empty, the strings are equal. • If one sequence is empty and the other is not, then the string corresponding to the empty sequence is less than the other string. • If the first integer in $A is less than the first integer in $B, then the string corresponding to $A is less than the string corresponding to $B. • If the first integer in $A is greater than the first integer in $B, then the string corresponding to $A is greater than the string corresponding to $B. • Otherwise (the first pair of integers are equal), the result is obtained by applying the same rules recursively to fn:tail($A) and fn:tail($B) Note: While the Unicode codepoint collation does not produce results suitable for quality publishing of printed indexes or directories, it is adequate for many purposes where a restricted alphabet is used, such as sorting of vehicle registrations. #### 5.3.3 The Unicode Collation Algorithm This specification defines a family of collation URIs representing tailorings of the Unicode Collation Algorithm (UCA) as defined in [UTS #10]. The parameters used for tailoring the UCA are based on the parameters defined in the Locale Data Markup Language (LDML), defined in [UTS #35]. This family of URIs use the scheme and path http://www.w3.org/2013/collation/UCA followed by an optional query part. The query part, if present, consists of a question mark followed by a sequence of zero or more semicolon-separated parameters. Each parameter is a keyword-value pair, the keyword and value being separated by an equals sign. All implementations must recognize URIs in this family in the collation argument of functions that take a collation argument. If the fallback parameter is present with the value no, then the implementation must either use a collation that conforms with the rules in the Unicode specifications for the requested tailoring, or fail with a static or dynamic error indicating that it does not provide the collation (the error code should be the same as if the collation URI were not recognized). If the fallback parameter is omitted or takes the value yes, and if the collation URI is well-formed according to the rules in this section, then the implementation must accept the collation URI, and should use the available collation that most closely reflects the user's intentions. For example, if the collation URI requested is http://www.w3.org/2013/collation/UCA?lang=se;fallback=yes and the implementation does not include a fully conformant version of the UCA tailored for Swedish, then it may choose to use a Swedish collation that is known to differ from the UCA definition, or one whose conformance has not been established. It might even, as a last resort, fall back to using codepoint collation. If two query parameters use the same keyword then the last one wins. If a query parameter uses a keyword or value which is not defined in this specification then the meaning is ·implementation-defined·. If the implementation recognizes the meaning of the keyword and value then it should interpret it accordingly; if it does not recognize the keyword or value then if the fallback parameter is present with the value no it should reject the collation as unsupported, otherwise it should ignore the unrecognized parameter. The following query parameters are defined. If any parameter is absent, the default is ·implementation-defined· except where otherwise stated. The meaning given for each parameter is non-normative; the normative specification is found in [UTS #35]. Keyword Values Meaning fallback yes | no (default yes) Determines whether the processor uses a fallback collation if a conformant collation is not available. lang language code: a string in the lexical space of xs:language. The language whose collation conventions are to be used. version string The version number of the UCA to be used. strength (default tertiary) primary | secondary | tertiary | quaternary | identical, or 1|2|3|4|5 as synonyms The collation strength as defined in UCA. Primary strength takes only the base form of the character into account (so A=a=Ä=ä); secondary strength ignores case but considers accents and diacritics as significant (so A=a and Ä=ä but ä≠a); tertiary considers case as significant (A≠a≠Ä≠ä); quaternary considers spaces and punctuation that would otherwise be ignored (for example data-base=database). maxVariable space | punct | symbol | currency (default punct) Indicates that all characters in the specified group and earlier groups are treated as "noise" characters to be handled as defined by the alternate parameter. For example, maxVariable=punct indicates that characters classified as whitespace or punctuation get this treatment. alternate non-ignorable | shifted | blanked (default non-ignorable) Controls the handling of characters such as spaces and hyphens; specifically, the "noise" characters in the groups selected by the maxVariable parameter. The value non-ignorable indicates that such characters are treated as distinct at the primary level (so data base sorts before datatype); shifted indicates that they are used to differentiate two strings only at the quaternary level, and blanked indicates that they are taken into account only at the identical level. backwards yes | no (default no) The value backwards=yes indicates that the last accent in the string is the most significant. normalization yes | no (default no) Indicates whether strings are converted to normalization form D. caseLevel yes | no (default no) When used with primary strength, setting caseLevel=yes has the effect of ignoring accents while taking account of case. caseFirst upper | lower Indicates whether upper-case precedes lower-case or vice versa. numeric yes | no (default no) When numeric=yes is specified, a sequence of consecutive digits is interpreted as a number, for example chap2 sorts before chap12. reorder a comma-separated sequence of reorder codes, where a reorder code is one of space, punct, symbol, currency, digit, or a four-letter script code defined in [ISO 15924 Register], the register of scripts maintained by the Unicode Consortium in its capacity as registration authority for [ISO 15924]. Determines the relative ordering of text in different scripts; for example the value digit,Grek,Latn indicates that digits precede Greek letters, which precede Latin letters. Note: This list excludes parameters that are inconvenient to express in a URI, or that are applicable only to substring matching. #### 5.3.4 The HTML ASCII Case-Insensitive Collation The collation URI http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive must be recognized by every implementation. It is used to refer to the HTML ASCII case-insensitive collation as defined in [HTML5: A vocabulary and associated APIs for HTML and XHTML] (section 2.5, Case sensitivity and string comparison). It is used, for example, when matching HTML class attribute values. Note: The definition of the collation is paraphrased here for convenience: Comparing two strings in an ASCII case-insensitive manner means comparing them exactly, codepoint for codepoint, except that the characters in the range x41 to x5A (A-Z) and the corresponding characters in the range x61 to x7A (a-z) are considered to also match. HTML5 defines the semantics of equality matching using this collation; it does not define rules for ordering. If the collation is used for ordering, the results are ·implementation-defined·. The collation supports collation units and can therefore be used with functions such as fn:contains; each Unicode codepoint is a single collation unit. #### 5.3.5 Choosing a collation Many functions have two signatures, where one signature includes a $collation argument and the other omits this argument.

The collation to use for these functions is determined by the following rules:

1. If the function specifies an explicit collation, CollationA (e.g., if the optional collation argument is specified in a call of the fn:compare function), then:

• If CollationA is supported by the implementation, then CollationA is used.

• Otherwise, a dynamic error is raised [err:FOCH0002].

2. If no collation is explicitly specified for the function and the default collation in the XQuery/XPath static context is CollationB, then:

• If CollationB is supported by the implementation, then CollationB is used.

• Otherwise, a dynamic error is raised [err:FOCH0002].

Note:

Because the set of collations that are supported is ·implementation-defined·, an implementation has the option to support all collation URIs, in which case it will never raise this error.

If the value of the collation argument is a relative URI reference, it is resolved against the base-URI from the static context. If it is a relative URI reference and cannot be resolved, perhaps because the base-URI property in the static context is absent, a dynamic error is raised [err:FOCH0002].

Note:

There is no explicit requirement that the string used as a collation URI be a valid URI. Implementations will in many cases reject such strings on the grounds that do not identify a supported collation; they may also cause an error if they cannot be resolved against the static base URI.

#### 5.3.6 fn:compare

Summary

Returns -1, 0, or 1, depending on whether $value1 collates before, equal to, or after $value2 according to the rules of a selected collation.

Signatures
 fn:compare( $value1 as xs:string?, $value2 as xs:string? ) as xs:integer?
 fn:compare( $value1 as xs:string?, $value2 as xs:string?, $collation as xs:string ) as xs:integer? Properties The two-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations. The three-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations, and static base URI. Rules Returns -1, 0, or 1, depending on whether $value1 is respectively less than, equal to, or greater than $value2, according to the rules of the collation that is used. The collation used by this function is determined according to the rules in 5.3.5 Choosing a collation. If either $value1 or $value2 is the empty sequence, the function returns the empty sequence. This function, called with the first signature, defines the semantics of the "eq", "ne", "gt", "lt", "le" and "ge" operators on xs:string values. Examples The expression fn:compare('abc', 'abc') returns 0. The expression fn:compare('Strasse', 'Straße') returns 0. (Assuming the default collation includes provisions that equate "ss" and the (German) character "ß" ("sharp-s"). Otherwise, the returned value depends on the semantics of the default collation.) The expression fn:compare('Strasse', 'Straße', 'http://www.w3.org/2013/collation/UCA?lang=de;strength=primary') returns 0. (The specified collation equates "ss" and the (German) character "ß" ("sharp-s").) The expression fn:compare('Strassen', 'Straße') returns 1. (Assuming the default collation includes provisions that treat differences between "ss" and the (German) character "ß" ("sharp-s") with less strength than the differences between the base characters, such as the final "n". ). #### 5.3.7 fn:codepoint-equal Summary Returns true if two strings are equal, considered codepoint-by-codepoint. Signature  fn:codepoint-equal( $value1 as xs:string?, $value2 as xs:string? ) as xs:boolean? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If either argument is the empty sequence, the function returns the empty sequence. Otherwise, the function returns true or false depending on whether $value1 is equal to $value2, according to the Unicode codepoint collation (http://www.w3.org/2005/xpath-functions/collation/codepoint). Notes This function allows xs:anyURI values to be compared without having to specify the Unicode codepoint collation. Examples The expression fn:codepoint-equal("abcd", "abcd") returns true(). The expression fn:codepoint-equal("abcd", "abcd ") returns false(). The expression fn:codepoint-equal("", "") returns true(). The expression fn:codepoint-equal("", ()) returns (). The expression fn:codepoint-equal((), ()) returns (). #### 5.3.8 fn:collation-key Summary Given a string value and a collation, generates an internal value called a collation key, with the property that the matching and ordering of collation keys reflects the matching and ordering of strings under the specified collation. Signatures  fn:collation-key( $value as xs:string ) as xs:base64Binary
 fn:collation-key( $value as xs:string, $collation as xs:string ) as xs:base64Binary
Properties

This function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations.

Rules

Calling the one-argument version of this function is equivalent to calling the two-argument version supplying the default collation as the second argument.

The function returns an ·implementation-dependent· value with the property that, for any two strings $K1 and $K2:

• collation-key($K1,$C) eq collation-key($K2,$C) if and only if compare($K1,$K2, $C) eq 0 • collation-key($K1, $C) lt collation-key($K2, $C) if and only if compare($K1, $K2,$C) lt 0

The collation used by this function is determined according to the rules in 5.3.5 Choosing a collation. Collation keys are defined as xs:base64Binary values to ensure unambiguous and context-free comparison semantics.

An implementation is free to generate a collation key in any convenient way provided that it always generates the same collation key for two strings that are equal under the collation, and different collation keys for strings that are not equal. This holds only within a single ·execution scope·; an implementation is under no obligation to generate the same collation keys during a subsequent unrelated query or transformation.

It is possible to define collations that do not have the ability to generate collation keys. Supplying such a collation will cause the function to fail. The ability to generate collation keys is an ·implementation-defined· property of the collation.

Error Conditions

An error is raised [err:FOCH0004] if the specified collation does not support the generation of collation keys.

Notes

The function is provided primarily for use with maps. If a map is required where codepoint equality is inappropriate for comparing keys, then a common technique is to normalize the key so that equality matching becomes feasible. There are many ways keys can be normalized, for example by use of functions such as fn:upper-case, fn:lower-case, fn:normalize-space, or fn:normalize-unicode, but this function provides a way of normalizing them according to the rules of a specified collation. For example, if the collation ignores accents, then the function will generate the same collation key for two input strings that differ only in their use of accents.

The result of the function is defined to be an xs:base64Binary value. Binary values are chosen because they have unambiguous and context-free comparison semantics, because the value space is unbounded, and because the ordering rules are such that between any two values in the ordered value space, an arbitrary number of further values can be interpolated. The choice between xs:base64Binary and xs:hexBinary is arbitrary; the only operation that behaves differently between the two binary data types is conversion to/from a string, and this operation is not one that is normally required for effective use of collation keys.

For collations based on the Unicode Collation Algorithm, an algorithm for computing collation keys is provided in [UTS #10]. Implementations are not required to use this algorithm.

The fact that collation keys are ordered can be exploited in XQuery, whose order by clause does not allow the collation to be selected dynamically. This restriction can be circumvented by rewriting the clause order by $e/@key collation "URI" as order by fn:collation-key($e/@key, $collation), where $collation allows the collation to be chosen dynamically.

Note that xs:base64Binary becomes an ordered type in XPath 3.1, making binary collation keys possible.

Examples
let $C := 'http://www.w3.org/2013/collation/UCA?strength=primary' The expression map:merge((map{collation-key("A",$C):1}, map{collation-key("a", $C):2}), map{"duplicates":"use-last"})(collation-key("A",$C)) returns 2. (Given that the keys of the two entries are equal under the rules of the chosen collation, only one of the entries can appear in the result; the one that is chosen is the one from the last map in the input sequence.)

The expression let $M := map{collation-key("A",$C):1, collation-key("B", $C):2} return$M(collation-key("a", $C)) returns 1. (The strings "A" and "a" have the same collation key under this collation.) As the above examples illustrate, it is important that when the collation-key function is used to add entries to a map, then it must also be used when retrieving entries from the map. This process can be made less error-prone by encapsulating the map within a function: function($k) {$M(collation-key($k, $collation)}. #### 5.3.9 fn:contains-token Summary Determines whether or not any of the supplied strings, when tokenized at whitespace boundaries, contains the supplied token, under the rules of the supplied collation. Signatures  fn:contains-token( $value as xs:string*, $token as xs:string ) as xs:boolean  fn:contains-token( $value as xs:string*, $token as xs:string, $collation as xs:string ) as xs:boolean
Properties

The two-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations.

The three-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations, and static base URI.

Rules

If $value is the empty sequence, the function returns false. Leading and trailing whitespace is trimmed from $token. If the trimmed value of $token is a zero-length string, the function returns false. The collation used by this function is determined according to the rules in 5.3.5 Choosing a collation. The function returns true if and only if there is string in $value which, after tokenizing at whitespace boundaries, contains a token that is equal to the trimmed value of $token under the rules of the selected collation. That is, the function returns the value of the expression: some$t in $input!fn:tokenize(.) satisfies compare($t, fn:replace($token, '^\s*|\s*$', ''), $collation) eq 0) Notes Interior whitespace within $token will cause the function to return false, unless such whitespace is ignored by the selected collation.

This function can be used for processing space-separated attribute values (for example, the XHTML and DITA class attribute), where one often needs to test for the presence of a single token in a space-separated list. The function is designed to work both when the attribute has been validated against an XSD list type, and when it appears as a single untyped string. It differs from the HTML 5 definition in that HTML 5 recognizes form feed (x0C) as a separator. To reproduce the HTML token matching behavior, the HTML ASCII case-insensitive collation should be used: see 5.3.4 The HTML ASCII Case-Insensitive Collation.

Examples

The expression fn:contains-token("red green blue ", "red") returns true().

The expression fn:contains-token(("red", "green", "blue"), " red ") returns true().

The expression fn:contains-token("red, green, blue", "red") returns false().

The expression fn:contains-token("red green blue", "RED", "http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive") returns true().

### 5.4 Functions on string values

The following functions are defined on values of type xs:string and types derived from it.

Function Meaning
fn:characters Splits the supplied string into a sequence of single-character strings.
fn:concat Returns the concatenation of the string values of the arguments.
fn:string-join Returns a string created by concatenating the items in a sequence, with a defined separator between adjacent items.
fn:substring Returns the part of $value beginning at the position indicated by $start and continuing for the number of ·characters· indicated by $length. fn:string-length Returns the number of ·characters· in a string. fn:normalize-space Returns $value with leading and trailing whitespace removed, and sequences of internal whitespace reduced to a single space character.
fn:normalize-unicode Returns $value after applying Unicode normalization. fn:upper-case Converts a string to upper case. fn:lower-case Converts a string to lower case. fn:translate Returns $value modified by replacing or removing individual characters.

Notes:

When the above operators and functions are applied to datatypes derived from xs:string, they are guaranteed to return values that are instances of xs:string, but the value might or might not be an instance of the particular subtype of xs:string to which they were applied.

The strings returned by fn:concat and fn:string-join are not guaranteed to be normalized. But see note in fn:concat.

#### 5.4.1 fn:characters

Summary

Splits the supplied string into a sequence of single-character strings.

Signature
 fn:characters( $value as xs:string? ) as xs:string* Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules The function returns a sequence of strings, each string having length 1, containing the corresponding ·character· in $value.

If $value is a zero-length string or the empty sequence, the function returns the empty sequence. More formally, the function returns the result of the expression fn:string-to-codepoints($value) ! fn:codepoints-to-string(.)

Examples

The expression fn:characters("Thérèse") returns ("T", "h", "é", "r", "è", "s", "e").

The expression fn:characters("") returns ().

The expression fn:characters(()) returns ().

The expression fn:characters("Banana") => fn:index-of("a") returns (2, 4, 6).

The expression fn:characters("stretch") => fn:string-join("-") returns "s-t-r-e-t-c-h".

The expression "Banana" => fn:characters() => fn:reverse() => fn:string-join() returns "ananaB".

History

New in 4.0. Accepted 2022-09-20, subject to improving the description.

#### 5.4.2 fn:concat

Summary

Returns the concatenation of the string values of the arguments.

Operator Mapping

The two-argument form of this function defines the semantics of the "||" operator.

Signature
 fn:concat( $value1 as xs:anyAtomicType?, $value2 as xs:anyAtomicType?, $... as xs:anyAtomicType? ) as xs:string Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules This function accepts two or more xs:anyAtomicType arguments and casts each one to xs:string. The function returns the xs:string that is the concatenation of the values of its arguments after conversion. If any argument is the empty sequence, that argument is treated as the zero-length string. The fn:concat function is specified to allow two or more arguments, which are concatenated together. This is the only function specified in this document that allows a variable number of arguments. This capability is retained for compatibility with [XML Path Language (XPath) Version 1.0]. Notes As mentioned in 5.1 String types Unicode normalization is not automatically applied to the result of fn:concat. If a normalized result is required, fn:normalize-unicode can be applied to the xs:string returned by fn:concat. The following XQuery: let$v1 := "I plan to go to Mu"
let $v2 := "?nchen in September" return concat($v1, $v2) where the "?" represents either the actual Unicode character COMBINING DIARESIS (Unicode codepoint U+0308) or "&#x0308;", will return: "I plan to go to Mu?nchen in September" where the "?" represents either the actual Unicode character COMBINING DIARESIS (Unicode codepoint U+0308) or "&#x0308;". It is worth noting that the returned value is not normalized in NFC; however, it is normalized in NFD. However, the following XQuery: let$v1 := "I plan to go to Mu"
let $v2 := "?nchen in September" return normalize-unicode(concat($v1, $v2)) where the "?" represents either the actual Unicode character COMBINING DIARESIS (Unicode codepoint U+0308) or "&#x0308;", will return: "I plan to go to München in September" This returned result is normalized in NFC. Examples The expression fn:concat('un', 'grateful') returns "ungrateful". The expression fn:concat('Thy ', (), 'old ', "groans", "", ' ring', ' yet', ' in', ' my', ' ancient',' ears.') returns "Thy old groans ring yet in my ancient ears.". The expression fn:concat('Ciao!',()) returns "Ciao!". The expression fn:concat('Ingratitude, ', 'thou ', 'marble-hearted', ' fiend!') returns "Ingratitude, thou marble-hearted fiend!". The expression fn:concat(01, 02, 03, 04, true()) returns "1234true". The expression 10 || '/' || 6 returns "10/6". #### 5.4.3 fn:string-join Summary Returns a string created by concatenating the items in a sequence, with a defined separator between adjacent items. Signatures  fn:string-join( $values as xs:anyAtomicType* ) as xs:string
 fn:string-join( $values as xs:anyAtomicType*, $separator as xs:string ) as xs:string
Properties

This function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

The effect of calling the single-argument version of this function is the same as calling the two-argument version with $separator set to a zero-length string. The function returns an xs:string created by casting each item in the sequence $values to an xs:string, and then concatenating the result strings in order, using the value of $separator as a separator between adjacent strings. If $separator is the zero-length string, then the items in $values are concatenated without a separator. Notes If $values is the empty sequence, the function returns the zero-length string.

Examples

The expression fn:string-join(1 to 9) returns "123456789".

The expression fn:string-join(('Now', 'is', 'the', 'time', '...'), ' ') returns "Now is the time ...".

The expression fn:string-join(('Blow, ', 'blow, ', 'thou ', 'winter ', 'wind!'), '') returns "Blow, blow, thou winter wind!".

The expression fn:string-join((), 'separator') returns "".

The expression fn:string-join(1 to 5, ', ') returns "1, 2, 3, 4, 5".

let $doc := <doc> <chap> <section xml:id="xyz"/> </chap> </doc> The expression $doc//@xml:id ! fn:string-join((node-name(), '="', ., '"')) returns 'xml:id="xyz"'.

The expression $doc//section ! fn:string-join(ancestor-or-self::*/name(), '/') returns "doc/chap/section". #### 5.4.4 fn:substring Summary Returns the part of $value beginning at the position indicated by $start and continuing for the number of ·characters· indicated by $length.

Signatures
 fn:substring( $value as xs:string?, $start as xs:double ) as xs:string
 fn:substring( $value as xs:string?, $start as xs:double, $length as xs:double ) as xs:string Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the zero-length string.

Otherwise, the function returns a string comprising those ·characters· of $value whose index position (counting from one) is greater than or equal to $start (rounded to an integer), and (if $length is specified) less than the sum of $start and $length (both rounded to integers). The characters returned do not extend beyond $value. If $start is zero or negative, only those characters in positions greater than zero are returned. More specifically, the three argument version of the function returns the characters in $value whose position $p satisfies: fn:round($start) <= $p and$p < fn:round($start) + fn:round($length)

The two argument version of the function assumes that $length is infinite and thus returns the ·characters· in $value whose position $p satisfies: fn:round($start) <= $p In the above computations, the rules for op:numeric-less-than and op:numeric-greater-than apply. Notes The first character of a string is located at position 1, not position 0. The second and third arguments allow xs:double values (rather than requiring xs:integer) in order to achieve compatibility with XPath 1.0. A surrogate pair counts as one character, not two. The consequences of supplying values such as NaN or positive or negative infinity for the $start or $length arguments follow from the above rules, and are not always intuitive. Examples The expression fn:substring("motor car", 6) returns " car". (Characters starting at position 6 to the end of $sourceString are selected.)

The expression fn:substring("metadata", 4, 3) returns "ada". (Characters at positions greater than or equal to 4 and less than 7 are selected.)

The expression fn:substring("12345", 1.5, 2.6) returns "234". (Characters at positions greater than or equal to 2 and less than 5 are selected.)

The expression fn:substring("12345", 0, 3) returns "12". (Characters at positions greater than or equal to 0 and less than 3 are selected. Since the first position is 1, these are the characters at positions 1 and 2.)

The expression fn:substring("12345", 5, -3) returns "". (Characters at positions greater than or equal to 5 and less than 2 are selected.)

The expression fn:substring("12345", -3, 5) returns "1". (Characters at positions greater than or equal to -3 and less than 2 are selected. Since the first position is 1, this is the character at position 1.)

The expression fn:substring("12345", 0 div 0E0, 3) returns "". (Since 0 div 0E0 returns NaN, and NaN compared to any other number returns false, no characters are selected.)

The expression fn:substring("12345", 1, 0 div 0E0) returns "". (As above.)

The expression fn:substring((), 1, 3) returns "".

The expression fn:substring("12345", -42, 1 div 0E0) returns "12345". (Characters at positions greater than or equal to -42 and less than INF are selected.)

The expression fn:substring("12345", -1 div 0E0, 1 div 0E0) returns "". (Since the value of -INF + INF is NaN, no characters are selected.)

#### 5.4.5 fn:string-length

Summary

Returns the number of ·characters· in a string.

Signatures
 fn:string-length() as xs:integer
 fn:string-length( $value as xs:string? ) as xs:integer Properties The zero-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-dependent·. The one-argument form of this function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules The function returns an xs:integer equal to the length in ·characters· of $value.

Calling the zero-argument version of the function is equivalent to calling fn:string-length(fn:string(.)).

If $value is the empty sequence, the function returns the xs:integer value zero (0). Error Conditions If $value is not specified and the context item is absentDM40, a dynamic error is raised: [err:XPDY0002]XP.

Notes

Unlike some programming languages, a ·codepoint· greater than 65535 counts as one character, not two.

There are situations where fn:string-length() has a different effect from fn:string-length(.). For example, if the context item is an attribute node typed as an xs:integer with the string value 000001, then fn:string-length() returns 6 (the length of the string value of the node), while fn:string-length(.) raises a type error (because the result of atomization is not an xs:string).

Examples

The expression fn:string-length("Harp not on that string, madam; that is past.") returns 45.

The expression fn:string-length(()) returns 0.

#### 5.4.6 fn:normalize-space

Summary

Returns $value with leading and trailing whitespace removed, and sequences of internal whitespace reduced to a single space character. Signatures  fn:normalize-space() as xs:string  fn:normalize-space( $value as xs:string? ) as xs:string
Properties

The zero-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-dependent·.

The one-argument form of this function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

If $value is the empty sequence, the function returns the zero-length string. The function returns a string constructed by stripping leading and trailing whitespace from $value, and replacing sequences of one or more adjacent whitespace characters with a single space, #x20.

The whitespace characters are defined in the metasymbol S (Production 3) of [Extensible Markup Language (XML) 1.0 (Fifth Edition)].

If no argument is supplied, then $value defaults to the string value (calculated using fn:string) of the context item (.). Error Conditions If no argument is supplied and the context item is absentDM40 then a dynamic error is raised: [err:XPDY0002]XP. Notes The definition of whitespace is unchanged in [Extensible Markup Language (XML) 1.1 Recommendation]. It is repeated here for convenience: S ::= (#x20 | #x9 | #xD | #xA)+ Examples The expression fn:normalize-space(" The wealthy curled darlings of our nation. ") returns "The wealthy curled darlings of our nation.". The expression fn:normalize-space(()) returns "". #### 5.4.7 fn:normalize-unicode Summary Returns $value after applying Unicode normalization.

Signatures
 fn:normalize-unicode( $value as xs:string? ) as xs:string  fn:normalize-unicode( $value as xs:string?, $form as xs:string ) as xs:string Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the zero-length string.

If the single-argument version of the function is used, the result is the same as calling the two-argument version with $form set to the string "NFC". Otherwise, the function returns $value normalized according to the rules of the normalization form identified by the value of $form. The effective value of $form is the value of the expression fn:upper-case(fn:normalize-space($form)). • If the effective value of $form is "NFC", then the function returns $value converted to Unicode Normalization Form C (NFC). • If the effective value of $form is "NFD", then the function returns $value converted to Unicode Normalization Form D (NFD). • If the effective value of $form is "NFKC", then the function returns $value in Unicode Normalization Form KC (NFKC). • If the effective value of $form is "NFKD", then the function returns $value converted to Unicode Normalization Form KD (NFKD). • If the effective value of $form is "FULLY-NORMALIZED", then the function returns $value converted to fully normalized form. • If the effective value of $form is the zero-length string, no normalization is performed and $value is returned. Normalization forms NFC, NFD, NFKC, and NFKD, and the algorithms to be used for converting a string to each of these forms, are defined in [UAX #15]. The motivation for normalization form FULLY-NORMALIZED is explained in [Character Model for the World Wide Web 1.0: Normalization]. However, as that specification did not progress beyond working draft status, the normative specification is as follows: • A string is fully-normalized if (a) it is in normalization form NFC as defined in [UAX #15], and (b) it does not start with a composing character. • A composing character is a character that is one or both of the following: • the second character in the canonical decomposition mapping of some character that is not listed in the Composition Exclusion Table defined in [UAX #15]; • of non-zero canonical combining class (as defined in [The Unicode Standard]). • A string is converted to FULLY-NORMALIZED form as follows: • if the first character in the string is a composing character, prepend a single space (x20); • convert the resulting string to normalization form NFC. Conforming implementations must support normalization form "NFC" and may support normalization forms "NFD", "NFKC", "NFKD", and "FULLY-NORMALIZED". They may also support other normalization forms with ·implementation-defined· semantics. It is ·implementation-defined· which version of Unicode (and therefore, of the normalization algorithms and their underlying data) is supported by the implementation. See [UAX #15] for details of the stability policy regarding changes to the normalization rules in future versions of Unicode. If the input string contains codepoints that are unassigned in the relevant version of Unicode, or for which no normalization rules are defined, the fn:normalize-unicode function leaves such codepoints unchanged. If the implementation supports the requested normalization form then it must be able to handle every input string without raising an error. Error Conditions A dynamic error is raised [err:FOCH0003] if the effective value of the $form argument is not one of the values supported by the implementation.

#### 5.4.8 fn:upper-case

Summary

Converts a string to upper case.

Signature
 fn:upper-case( $value as xs:string? ) as xs:string Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the zero-length string is returned.

Otherwise, the function returns $value after translating every ·character· to its upper-case correspondent as defined in the appropriate case mappings section in the Unicode standard [The Unicode Standard]. For versions of Unicode beginning with the 2.1.8 update, only locale-insensitive case mappings should be applied. Beginning with version 3.2.0 (and likely future versions) of Unicode, precise mappings are described in default case operations, which are full case mappings in the absence of tailoring for particular languages and environments. Every lower-case character that does not have an upper-case correspondent, as well as every upper-case character, is included in the returned value in its original form. Notes Case mappings may change the length of a string. In general, the fn:upper-case and fn:lower-case functions are not inverses of each other: fn:lower-case(fn:upper-case($s)) is not guaranteed to return $s, nor is fn:upper-case(fn:lower-case($s)). The Latin small letter dotless i (as used in Turkish) is perhaps the most prominent lower-case letter which will not round-trip. The Latin capital letter i with dot above is the most prominent upper-case letter which will not round trip; there are others, such as Latin capital letter Sharp S (#1E9E) which was introduced in Unicode 5.1.

These functions may not always be linguistically appropriate (e.g. Turkish i without dot) or appropriate for the application (e.g. titlecase). In cases such as Turkish, a simple translation should be used first.

Because the function is not sensitive to locale, results will not always match user expectations. In Quebec, for example, the standard uppercase equivalent of "è" is "È", while in metropolitan France it is more commonly "E"; only one of these is supported by the functions as defined.

Many characters of class Ll lack uppercase equivalents in the Unicode case mapping tables; many characters of class Lu lack lowercase equivalents.

Examples

The expression fn:upper-case("abCd0") returns "ABCD0".

#### 5.4.9 fn:lower-case

Summary

Converts a string to lower case.

Signature
 fn:lower-case( $value as xs:string? ) as xs:string Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If t$value is the empty sequence, the zero-length string is returned.

Otherwise, the function returns $value after translating every ·character· to its lower-case correspondent as defined in the appropriate case mappings section in the Unicode standard [The Unicode Standard]. For versions of Unicode beginning with the 2.1.8 update, only locale-insensitive case mappings should be applied. Beginning with version 3.2.0 (and likely future versions) of Unicode, precise mappings are described in default case operations, which are full case mappings in the absence of tailoring for particular languages and environments. Every upper-case character that does not have a lower-case correspondent, as well as every lower-case character, is included in the returned value in its original form. Notes Case mappings may change the length of a string. In general, the fn:upper-case and fn:lower-case functions are not inverses of each other: fn:lower-case(fn:upper-case($s)) is not guaranteed to return $s, nor is fn:upper-case(fn:lower-case($s)). The Latin small letter dotless i (as used in Turkish) is perhaps the most prominent lower-case letter which will not round-trip. The Latin capital letter i with dot above is the most prominent upper-case letter which will not round trip; there are others, such as Latin capital letter Sharp S (#1E9E) which was introduced in Unicode 5.1.

These functions may not always be linguistically appropriate (e.g. Turkish i without dot) or appropriate for the application (e.g. titlecase). In cases such as Turkish, a simple translation should be used first.

Because the function is not sensitive to locale, results will not always match user expectations. In Quebec, for example, the standard uppercase equivalent of "è" is "È", while in metropolitan France it is more commonly "E"; only one of these is supported by the functions as defined.

Many characters of class Ll lack uppercase equivalents in the Unicode case mapping tables; many characters of class Lu lack lowercase equivalents.

Examples

The expression fn:lower-case("ABc!D") returns "abc!d".

#### 5.4.10 fn:translate

Summary

Returns $value modified by replacing or removing individual characters. Signature  fn:translate( $value as xs:string?, $replace as xs:string, $with as xs:string ) as xs:string
Properties

This function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

If $value is the empty sequence, the function returns the zero-length string. Otherwise, the function returns a result string constructed by processing each ·character· in $value, in order, according to the following rules:

1. If the character does not appear in $replace then it is added to the result string unchanged. 2. If the character first appears in $replace at some position M, where the value of $with is M or more characters in length, then the character at position M in $with is added to the result string.

3. If the character first appears in $replace at some position M, where $with is less than M characters in length, then the character is omitted from the result string.

Notes

If $replace is the zero-length string then the function returns $value unchanged.

If a character occurs more than once in $replace, then the first occurrence determines the action taken. If $with is longer than $replace, the excess characters are ignored. Examples The expression fn:translate("bar","abc","ABC") returns "BAr". The expression fn:translate("--aaa--","abc-","ABC") returns "AAA". The expression fn:translate("abcdabc", "abc", "AB") returns "ABdAB". ### 5.5 Functions based on substring matching The functions described in the section examine a string $arg1 to see whether it contains another string $arg2 as a substring. The result depends on whether $arg2 is a substring of $arg1, and if so, on the range of ·characters· in $arg1 which $arg2 matches. When the ·Unicode codepoint collation· is used, this simply involves determining whether $arg1 contains a contiguous sequence of characters whose ·codepoints· are the same, one for one, with the codepoints of the characters in $arg2. When a collation is specified, the rules are more complex. All collations support the capability of deciding whether two ·strings· are considered equal, and if not, which of the strings should be regarded as preceding the other. For functions such as fn:compare, this is all that is required. For other functions, such as fn:contains, the collation needs to support an additional property: it must be able to decompose the string into a sequence of collation units, each unit consisting of one or more characters, such that two strings can be compared by pairwise comparison of these units. ("collation unit" is equivalent to "collation element" as defined in [UTS #10].) The string $arg1 is then considered to contain $arg2 as a substring if the sequence of collation units corresponding to $arg2 is a subsequence of the sequence of the collation units corresponding to $arg1. The characters in $arg1 that match are the characters corresponding to these collation units.

This rule may occasionally lead to surprises. For example, consider a collation that treats "Jaeger" and "Jäger" as equal. It might do this by treating "ä" as representing two collation units, in which case the expression fn:contains("Jäger", "eg") will return true. Alternatively, a collation might treat "ae" as a single collation unit, in which case the expression fn:contains("Jaeger", "eg") will return false. The results of these functions thus depend strongly on the properties of the collation that is used.

In addition, collations may specify that some collation units should be ignored during matching. If hyphen is an ignored collation unit, then fn:contains("code-point", "codepoint") will be true, and fn:contains("codepoint", "-") will also be true.

In the definitions below, we refer to the terms match and minimal match as defined in definitions DS2 and DS4 of [UTS #10]. In applying these definitions:

• C is the collation; that is, the value of the $collation argument if specified, otherwise the default collation. • P is the (candidate) substring $arg2

• Q is the (candidate) containing string $arg1 • The boundary condition B is satisfied at the start and end of a string, and between any two characters that belong to different collation units ("collation elements" in the language of [UTS #10]). It is not satisfied between two characters that belong to the same collation unit. It is possible to define collations that do not have the ability to decompose a string into units suitable for substring matching. An argument to a function defined in this section may be a URI that identifies a collation that is able to compare two strings, but that does not have the capability to split the string into collation units. Such a collation may cause the function to fail, or to give unexpected results or it may be rejected as an unsuitable argument. The ability to decompose strings into collation units is an ·implementation-defined· property of the collation. Function Meaning fn:contains Returns true if the string $value contains $substring as a substring, taking collations into account. fn:starts-with Returns true if the string $value contains $substring as a leading substring, taking collations into account. fn:ends-with Returns true if the string $value contains $substring as a trailing substring, taking collations into account. fn:substring-before Returns the part of $value that precedes the first occurrence of $substring, taking collations into account. fn:substring-after Returns the part of $value that follows the first occurrence of $substring, taking collations into account. #### 5.5.1 fn:contains Summary Returns true if the string $value contains $substring as a substring, taking collations into account. Signatures  fn:contains( $value as xs:string?, $substring as xs:string? ) as xs:boolean  fn:contains( $value as xs:string?, $substring as xs:string?, $collation as xs:string ) as xs:boolean
Properties

The two-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations.

The three-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations, and static base URI.

Rules

If $value or $substring is the empty sequence, or contains only ignorable collation units, it is interpreted as the zero-length string.

If $substring is the zero-length string, then the function returns true. If $value is the zero-length string, the function returns false.

The collation used by this function is determined according to the rules in 5.3.5 Choosing a collation.

The function returns an xs:boolean indicating whether or not $value contains (at the beginning, at the end, or anywhere within) at least one sequence of collation units that provides a minimal match to the collation units in $substring, according to the collation that is used.

Note:

Minimal match is defined in [UTS #10].

Error Conditions

A dynamic error may be raised [err:FOCH0004] if the specified collation does not support collation units.

Examples

The collation used in these examples, http://example.com/CollationA is a collation in which both "-" and "*" are ignorable collation units.

"Ignorable collation unit" is equivalent to "ignorable collation element" in [UTS #10].

The expression fn:contains ( "tattoo", "t") returns true().

The expression fn:contains ( "tattoo", "ttt") returns false().

The expression fn:contains ( "", ()) returns true(). (The first rule is applied, followed by the second rule.)

The expression fn:contains ( "abcdefghi", "-d-e-f-", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns true().

The expression fn:contains ( "a*b*c*d*e*f*g*h*i*", "d-ef-", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns true().

The expression fn:contains ( "abcd***e---f*--*ghi", "def", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns true().

The expression fn:contains ( (), "--***-*---", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns true(). (The second argument contains only ignorable collation units and is equivalent to the zero-length string.)

#### 5.5.2 fn:starts-with

Summary

Returns true if the string $value contains $substring as a leading substring, taking collations into account.

Signatures
 fn:starts-with( $value as xs:string?, $substring as xs:string? ) as xs:boolean
 fn:starts-with( $value as xs:string?, $substring as xs:string?, $collation as xs:string ) as xs:boolean Properties The two-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations. The three-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations, and static base URI. Rules If $value or $substring is the empty sequence, or contains only ignorable collation units, it is interpreted as the zero-length string. If $substring is the zero-length string, then the function returns true. If $value is the zero-length string and $substring is not the zero-length string, then the function returns false.

The collation used by this function is determined according to the rules in 5.3.5 Choosing a collation.

The function returns an xs:boolean indicating whether or not $value starts with a sequence of collation units that provides a match to the collation units of $substring according to the collation that is used.

Note:

Match is defined in [UTS #10].

Error Conditions

A dynamic error may be raised [err:FOCH0004] if the specified collation does not support collation units.

Examples

The collation used in these examples, http://example.com/CollationA is a collation in which both "-" and "*" are ignorable collation units.

"Ignorable collation unit" is equivalent to "ignorable collation element" in [UTS #10].

The expression fn:starts-with("tattoo", "tat") returns true().

The expression fn:starts-with ( "tattoo", "att") returns false().

The expression fn:starts-with ((), ()) returns true().

The expression fn:starts-with ( "abcdefghi", "-a-b-c-", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns true().

The expression fn:starts-with ( "a*b*c*d*e*f*g*h*i*", "a-bc-", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns true().

The expression fn:starts-with ( "abcd***e---f*--*ghi", "abcdef", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns true().

The expression fn:starts-with ( (), "--***-*---", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns true(). (The second argument contains only ignorable collation units and is equivalent to the zero-length string.)

The expression fn:starts-with ( "-abcdefghi", "-abc", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns true().

#### 5.5.3 fn:ends-with

Summary

Returns true if the string $value contains $substring as a trailing substring, taking collations into account.

Signatures
 fn:ends-with( $value as xs:string?, $substring as xs:string? ) as xs:boolean
 fn:ends-with( $value as xs:string?, $substring as xs:string?, $collation as xs:string ) as xs:boolean Properties The two-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations. The three-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations, and static base URI. Rules If $value or $substring is the empty sequence, or contains only ignorable collation units, it is interpreted as the zero-length string. If $substring is the zero-length string, then the function returns true. If $value is the zero-length string and the value of $substring is not the zero-length string, then the function returns false.

The collation used by this function is determined according to the rules in 5.3.5 Choosing a collation.

The function returns an xs:boolean indicating whether or not $value ends with a sequence of collation units that provides a match to the collation units of $substring according to the collation that is used.

Note:

Match is defined in [UTS #10].

Error Conditions

A dynamic error may be raised [err:FOCH0004] if the specified collation does not support collation units.

Examples

The collation used in these examples, http://example.com/CollationA is a collation in which both "-" and "*" are ignorable collation units.

"Ignorable collation unit" is equivalent to "ignorable collation element" in [UTS #10].

The expression fn:ends-with ( "tattoo", "tattoo") returns true().

The expression fn:ends-with ( "tattoo", "atto") returns false().

The expression fn:ends-with ((), ()) returns true().

The expression fn:ends-with ( "abcdefghi", "-g-h-i-", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns true().

The expression fn:ends-with ( "abcd***e---f*--*ghi", "defghi", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns true().

The expression fn:ends-with ( "abcd***e---f*--*ghi", "defghi", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns true().

The expression fn:ends-with ( (), "--***-*---", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns true(). (The second argument contains only ignorable collation units and is equivalent to the zero-length string.)

The expression fn:ends-with ( "abcdefghi", "ghi-", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns true().

#### 5.5.4 fn:substring-before

Summary

Returns the part of $value that precedes the first occurrence of $substring, taking collations into account.

Signatures
 fn:substring-before( $value as xs:string?, $substring as xs:string? ) as xs:string
 fn:substring-before( $value as xs:string?, $substring as xs:string?, $collation as xs:string ) as xs:string Properties The two-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations. The three-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations, and static base URI. Rules If $value or $substring is the empty sequence, or contains only ignorable collation units, it is interpreted as the zero-length string. If $substring is the zero-length string, then the function returns the zero-length string.

If $value does not contain a string that is equal to $substring, then the function returns the zero-length string.

The collation used by this function is determined according to the rules in 5.3.5 Choosing a collation.

The function returns the substring of $value that precedes in $value the first occurrence of a sequence of collation units that provides a minimal match to the collation units of $substring according to the collation that is used. Note: Minimal match is defined in [UTS #10]. Error Conditions A dynamic error may be raised [err:FOCH0004] if the specified collation does not support collation units. Examples The collation used in these examples, http://example.com/CollationA is a collation in which both "-" and "*" are ignorable collation units. "Ignorable collation unit" is equivalent to "ignorable collation element" in [UTS #10]. The expression fn:substring-before ( "tattoo", "attoo") returns "t". The expression fn:substring-before ( "tattoo", "tatto") returns "". The expression fn:substring-before ((), ()) returns "". The expression fn:substring-before ( "abcdefghi", "--d-e-", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns "abc". The expression fn:substring-before ( "abc--d-e-fghi", "--d-e-", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns "abc--". The expression fn:substring-before ( "a*b*c*d*e*f*g*h*i*", "***cde", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns "a*b*". The expression fn:substring-before ( "Eureka!", "--***-*---", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns "". (The second argument contains only ignorable collation units and is equivalent to the zero-length string.) #### 5.5.5 fn:substring-after Summary Returns the part of $value that follows the first occurrence of $substring, taking collations into account. Signatures  fn:substring-after( $value as xs:string?, $substring as xs:string? ) as xs:string  fn:substring-after( $value as xs:string?, $substring as xs:string?, $collation as xs:string ) as xs:string
Properties

The two-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations.

The three-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on collations, and static base URI.

Rules

If $value or $substring is the empty sequence, or contains only ignorable collation units, it is interpreted as the zero-length string.

If $substring is the zero-length string, then the function returns the value of $value.

If $value does not contain a string that is equal to $substring, then the function returns the zero-length string.

The collation used by this function is determined according to the rules in 5.3.5 Choosing a collation.

The function returns the substring of $value that follows in $value the first occurrence of a sequence of collation units that provides a minimal match to the collation units of $substring according to the collation that is used. Note: Minimal match is defined in [UTS #10]. Error Conditions A dynamic error may be raised [err:FOCH0004] if the specified collation does not support collation units. Examples The collation used in these examples, http://example.com/CollationA is a collation in which both "-" and "*" are ignorable collation units. "Ignorable collation unit" is equivalent to "ignorable collation element" in [UTS #10]. The expression fn:substring-after("tattoo", "tat") returns "too". The expression fn:substring-after("tattoo", "tattoo") returns "". The expression fn:substring-after((), ()) returns "". The expression  fn:substring-after("abcdefghi", "--d-e-", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns "fghi". The expression fn:substring-after("abc--d-e-fghi", "--d-e-", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns "-fghi". The expression fn:substring-after ( "a*b*c*d*e*f*g*h*i*", "***cde***", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns "*f*g*h*i*". The expression fn:substring-after ( "Eureka!", "--***-*---", "http://www.w3.org/2013/collation/UCA?lang=en;alternate=blanked;strength=primary") returns "Eureka!". (The second argument contains only ignorable collation units and is equivalent to the zero-length string.) ### 5.6 String functions that use regular expressions The three functions described in this section make use of a regular expression syntax for pattern matching. This is described below. Function Meaning fn:matches Returns true if the supplied string matches a given regular expression. fn:replace Returns a string produced from the input string by replacing any substrings that match a given regular expression with a supplied replacement string, provided either literally, or by invoking a supplied function. fn:tokenize Returns a sequence of strings constructed by splitting the input wherever a separator is found; the separator is any substring that matches a given regular expression. fn:analyze-string Analyzes a string using a regular expression, returning an XML structure that identifies which parts of the input string matched or failed to match the regular expression, and in the case of matched substrings, which substrings matched each capturing group in the regular expression. #### 5.6.1 Regular expression syntax The regular expression syntax used by these functions is defined in terms of the regular expression syntax specified in XML Schema (see [XML Schema Part 2: Datatypes Second Edition]), which in turn is based on the established conventions of languages such as Perl. However, because XML Schema uses regular expressions only for validity checking, it omits some facilities that are widely used with languages such as Perl. This section, therefore, describes extensions to the XML Schema regular expressions syntax that reinstate these capabilities. Note: It is recommended that implementers consult [UTS #18] for information on using regular expression processing on Unicode characters. The regular expression syntax and semantics are identical to those defined in [XML Schema Part 2: Datatypes Second Edition] with the additions described in the following sub-sections. Note: In [Schema 1.1 Part 2] there are no substantive technical changes to the syntax or semantics of regular expressions relative to XSD 1.0, but a number of errors and ambiguities have been resolved. For example, the rules for the interpretation of hyphens within square brackets in a regular expression have been clarified; and the semantics of regular expressions are no longer tied to a specific version of Unicode. Implementers, even in cases where XSD 1.1 is not supported, are advised to consult the XSD 1.1 regular expression specification for guidance on how to handle cases where the XSD 1.0 specification is unclear or inconsistent. ##### 5.6.1.1 Matching the Start and End of the String Two meta-characters, ^ and $ are added. By default, the meta-character ^ matches the start of the entire string, while $ matches the end of the entire string. In multi-line mode, ^ matches the start of any line (that is, the start of the entire string, and the position immediately after a newline character), while $ matches the end of any line (that is, the end of the entire string, and the position immediately before a newline character). Newline here means the character #x0A only.

This means that the production in [XML Schema Part 2: Datatypes Second Edition]:

[10] Char ::= [^.\?*+()|#x5B#x5D]

[10] Char ::= [^.\?*+{}()|^$#x5B#x5D] The XSD 1.1 grammar for regular expressions uses the same production rule, but renumbered and renamed [73] NormalChar; it is affected in the same way. The characters #x5B and #x5D correspond to "[" and "]" respectively. Note: The definition of Char (production [10]) in [XML Schema Part 2: Datatypes Second Edition] has a known error in which it omits the left brace ("{") and right brace ("}"). That error is corrected here. The following production: [11] charClass ::= charClassEsc | charClassExpr | WildCardEsc is modified to read: [11] charClass ::= charClassEsc | charClassExpr | WildCardEsc | "^" | "$"

Using XSD 1.1 as the baseline the equivalent is to change the production:

[74] charClass ::= SingleCharEsc | charClassEsc | charClassExpr | WildCardEsc

[74] charClass ::= SingleCharEsc | charClassEsc | charClassExpr | WildCardEsc | "^" | "$" Single character escapes are extended to allow the $ character to be escaped. The following production is changed:

[24]SingleCharEsc ::= '\' [nrt\|.?*+(){}#x2D#x5B#x5D#x5E]

to

[24]SingleCharEsc ::= '\' [nrt\|.?*+(){}$#x2D#x5B#x5D#x5E] (In the XSD 1.1 version of the regular expression grammar, the production rule for SingleCharEsc is unchanged, but is renumbered [84]) ##### 5.6.1.2 Reluctant Quantifiers Reluctant quantifiers are supported. They are indicated by a ? following a quantifier. Specifically: • X?? matches X, once or not at all • X*? matches X, zero or more times • X+? matches X, one or more times • X{n}? matches X, exactly n times • X{n,}? matches X, at least n times • X{n,m}? matches X, at least n times, but not more than m times The effect of these quantifiers is that the regular expression matches the shortest possible substring consistent with the match as a whole succeeding. Without the ? , the regular expression matches the longest possible substring. To achieve this, the production in [XML Schema Part 2: Datatypes Second Edition]: [4] quantifier ::= [?*+] | ( '{' quantity '}' ) is changed to: [4] quantifier ::= ( [?*+] | ( '{' quantity '}' ) ) '?'? (In the XSD 1.1 version of the regular expression grammar, this rule is unchanged, but is renumbered [67]) Note: Reluctant quantifiers have no effect on the results of the boolean fn:matches function, since this function is only interested in discovering whether a match exists, and not where it exists. ##### 5.6.1.3 Captured Sub-Expressions Sub-expressions (groups) within the regular expression are recognized. The regular expression syntax defined by [XML Schema Part 2: Datatypes Second Edition] allows a regular expression to contain parenthesized sub-expressions, but attaches no special significance to them. Some operations associated with regular expressions (for example, back-references, and the fn:replace function) allow access to the parts of the input string that matched a sub-expression (called captured substrings). [Definition] A left parenthesis is recognized as a capturing left parenthesis provided it is not immediately followed by ?: (see below), is not within a character group (square brackets), and is not escaped with a backslash. The sub-expression enclosed by a capturing left parenthesis and its matching right parenthesis is referred to as a capturing sub-expression. More specifically, the ·capturing sub-expression· enclosed by the Nth capturing left parenthesis within the regular expression (determined by its character position in left-to-right order, and counting from one) is referred to as the Nth capturing sub-expression. For example, in the regular expression A(BC(?:D(EF(GH[()])))), the string matched by the sub-expression BC(?:D(EF(GH[()]))) is capturing sub-expression 1, the string matched by EF(GH[()]) is capturing sub-expression 2, and the string matched by GH[()] is capturing sub-expression 3. When, in the course of evaluating a regular expression, a particular substring of the input matches a capturing sub-expression, that substring becomes available as a captured substring. The string matched by the Nth capturing sub-expression is referred to as the Nth captured substring. By convention, the substring captured by the entire regular expression is treated as captured substring 0 (zero). When a ·capturing sub-expression· is matched more than once (because it is within a construct that allows repetition), then only the last substring that it matched will be captured. Note that this rule is not sufficient in all cases to ensure an unambiguous result, especially in cases where (a) the regular expression contains nested repeating constructs, and/or (b) the repeating construct matches a zero-length string. In such cases it is implementation-dependent which substring is captured. For example given the regular expression (a*)+ and the input string "aaaa", an implementation might legitimately capture either "aaaa" or a zero length string as the content of the captured subgroup. Parentheses that are required to group terms within the regular expression, but which are not required for capturing of substrings, can be represented using the syntax (?:xxxx). To achieve this, the production rule for atom in [XML Schema Part 2: Datatypes Second Edition] is changed to replace the alternative: ( '(' regExp ')' ) with: ( '(' '?:'? regExp ')' ) (For the new versions of the XSD 1.0 and XSD 1.1 production rules for atom, see below.) In the absence of back-references (see below), the presence of the optional ?: has no effect on the set of strings that match the regular expression, but causes the left parenthesis not to be counted by operations (such as fn:replace and back-references) that number the capturing sub-expressions within a regular expression. ##### 5.6.1.4 Back-References Back-references are allowed outside a character class expression. A back-reference is an additional kind of atom. The construct \N where N is a single digit is always recognized as a back-reference; if this is followed by further digits, these digits are taken to be part of the back-reference if and only if the resulting number NN is such that the back-reference is preceded by the opening parenthesis of the NNth capturing left parenthesis. The regular expression is invalid if a back-reference refers to a capturing sub-expression that does not exist or whose closing right parenthesis occurs after the back-reference. A back-reference with number N matches a string that is the same as the value of the Nth captured substring. For example, the regular expression ('|").*\1 matches a sequence of characters delimited either by an apostrophe at the start and end, or by a quotation mark at the start and end. If no string has been matched by the Nth capturing sub-expression, the back-reference is interpreted as matching a zero-length string. Combining this change with the introduction of non-capturing groups (see above), back-references change the following production: [9] atom ::= Char | charClass | ( '(' regExp ')' ) to [9] atom ::= Char | charClass | ( '(' '?:'? regExp ')' ) | backReference [9a] backReference ::= "\" [1-9][0-9]* With respect to the XSD 1.1 version of the regular expression grammar, the effect is to change: [72] atom ::= NormalChar | charClass | ( '(' regExp ')' ) to [72] atom ::= NormalChar | charClass | ( '(' '?:'? regExp ')' ) | backReference [72a] backReference ::= "\" [1-9][0-9]* Note: Within a character class expression, \ followed by a digit is invalid. Some other regular expression languages interpret this as an octal character reference. ##### 5.6.1.5 Unicode Block Names A regular expression that uses a Unicode block name that is not defined in the version(s) of Unicode supported by the processor (for example \p{IsBadBlockName}) is deemed to be invalid [err:FORX0002]. Note: XSD 1.0 does not say how this situation should be handled; XSD 1.1 says that it should be handled by treating all characters as matching. #### 5.6.2 Flags All these functions provide an optional parameter, $flags, to set options for the interpretation of the regular expression. The parameter accepts a xs:string, in which individual letters are used to set options. The presence of a letter within the string indicates that the option is on; its absence indicates that the option is off. Letters may appear in any order and may be repeated. If there are characters present that are not defined here as flags, then a dynamic error is raised [err:FORX0001].

The following options are defined:

• s: If present, the match operates in "dot-all" mode. (Perl calls this the single-line mode.) If the s flag is not specified, the meta-character . matches any character except a newline (#x0A) or carriage return (#x0D) character. In dot-all mode, the meta-character . matches any character whatsoever. Suppose the input contains "hello" and "world" on two lines. This will not be matched by the regular expression "hello.*world" unless dot-all mode is enabled.

• m: If present, the match operates in multi-line mode. By default, the meta-character ^ matches the start of the entire string, while $matches the end of the entire string. In multi-line mode, ^ matches the start of any line (that is, the start of the entire string, and the position immediately after a newline character other than a newline that appears as the last character in the string), while $ matches the end of any line (that is, the position immediately before a newline character, and the end of the entire string if there is no newline character at the end of the string). Newline here means the character #x0A only.

• i: If present, the match operates in case-insensitive mode. The detailed rules are as follows. In these rules, a character C2 is considered to be a case-variant of another character C1 if the following XPath expression returns true when the two characters are considered as strings of length one, and the ·Unicode codepoint collation· is used:

fn:lower-case(C1) eq fn:lower-case(C2) or fn:upper-case(C1) eq fn:upper-case(C2)

Note that the case-variants of a character under this definition are always single characters.

1. When a normal character (Char) is used as an atom, it represents the set containing that character and all its case-variants. For example, the regular expression "z" will match both "z" and "Z".

2. A character range (production charRange in the XSD 1.0 grammar, replaced by productions charRange and singleChar in XSD 1.1) represents the set containing all the characters that it would match in the absence of the "i" flag, together with their case-variants. For example, the regular expression "[A-Z]" will match all the letters A-Z and all the letters a-z. It will also match certain other characters such as #x212A (KELVIN SIGN), since fn:lower-case("#x212A") is "k".

This rule applies also to a character range used in a character class subtraction (charClassSub): thus [A-Z-[IO]] will match characters such as "A", "B", "a", and "b", but will not match "I", "O", "i", or "o".

The rule also applies to a character range used as part of a negative character group: thus [^Q] will match every character except "Q" and "q" (these being the only case-variants of "Q" in Unicode).

3. A back-reference is compared using case-blind comparison: that is, each character must either be the same as the corresponding character of the previously matched string, or must be a case-variant of that character. For example, the strings "Mum", "mom", "Dad", and "DUD" all match the regular expression "([md])[aeiou]\1" when the "i" flag is used.

4. All other constructs are unaffected by the "i" flag. For example, "\p{Lu}" continues to match upper-case letters only.

• x: If present, whitespace characters (#x9, #xA, #xD and #x20) in the regular expression are removed prior to matching with one exception: whitespace characters within character class expressions (charClassExpr) are not removed. This flag can be used, for example, to break up long regular expressions into readable lines.

Examples:

fn:matches("helloworld", "hello world", "x") returns true()

fn:matches("helloworld", "hello[ ]world", "x") returns false()

fn:matches("hello world", "hello\ sworld", "x") returns true()

fn:matches("hello world", "hello world", "x") returns false()

• q: if present, all characters in the regular expression are treated as representing themselves, not as metacharacters. In effect, every character that would normally have a special meaning in a regular expression is implicitly escaped by preceding it with a backslash.

Furthermore, when this flag is present, the characters $ and \ have no special significance when used in the replacement string supplied to the fn:replace function. This flag can be used in conjunction with the i flag. If it is used together with the m, s, or x flag, that flag has no effect. Examples: fn:tokenize("12.3.5.6", ".", "q") returns ("12", "3", "5", "6") fn:replace("a\b\c", "\", "\\", "q") returns "a\\b\\c" fn:replace("a/b/c", "/", "$", "q") returns "a$b$c"

fn:matches("abcd", ".*", "q") returns false()

fn:matches("Mr. B. Obama", "B. OBAMA", "iq") returns true()

#### 5.6.3 fn:matches

Summary

Returns true if the supplied string matches a given regular expression.

Signatures
 fn:matches( $value as xs:string?, $pattern as xs:string ) as xs:boolean
 fn:matches( $value as xs:string?, $pattern as xs:string, $flags as xs:string ) as xs:boolean Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules The effect of calling the first version of this function (omitting the argument $flags) is the same as the effect of calling the second version with the $flags argument set to a zero-length string. Flags are defined in 5.6.2 Flags. If $value is the empty sequence, it is interpreted as the zero-length string.

The function returns true if $value or some substring of $value matches the regular expression supplied as $pattern. Otherwise, the function returns false. The matching rules are influenced by $flags if present.

Error Conditions

A dynamic error is raised [err:FORX0002] if $pattern is invalid according to the rules described in 5.6.1 Regular expression syntax. A dynamic error is raised [err:FORX0001] if $flags is invalid according to the rules described in 5.6.2 Flags.

Notes

Unless the metacharacters ^ and $ are used as anchors, the string is considered to match the pattern if any substring matches the pattern. But if anchors are used, the anchors must match the start/end of the string (in string mode), or the start/end of a line (in multi-line mode). This is different from the behavior of patterns in [XML Schema Part 2: Datatypes Second Edition], where regular expressions are implicitly anchored. Regular expression matching is defined on the basis of Unicode code points; it takes no account of collations. Examples The expression fn:matches("abracadabra", "bra") returns true(). The expression fn:matches("abracadabra", "^a.*a$") returns true().

The expression fn:matches("abracadabra", "^bra") returns false().

Given the source document:

let $poem := <poem author="Wilhelm Busch"> Kaum hat dies der Hahn gesehen, Fängt er auch schon an zu krähen: Kikeriki! Kikikerikih!! Tak, tak, tak! - da kommen sie. </poem> the following function calls produce the following results, with the poem element as the context node: The expression fn:matches($poem, "Kaum.*krähen") returns false().

The expression fn:matches($poem, "Kaum.*krähen", "s") returns true(). The expression fn:matches($poem, "^Kaum.*gesehen,$", "m") returns true(). The expression fn:matches($poem, "^Kaum.*gesehen,$") returns false(). The expression fn:matches($poem, "kiki", "i") returns true().

#### 5.6.4 fn:replace

Summary

Returns a string produced from the input string by replacing any substrings that match a given regular expression with a supplied replacement string, provided either literally, or by invoking a supplied function.

Signature
 fn:replace( $value as xs:string?, $pattern as xs:string, $replacement as xs:string? := (), $flags as xs:string? := '', $action as (function(xs:string, xs:string*) as xs:string?)? := () ) as xs:string Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If the $flags argument is omitted, the effect is the same as supplying a zero-length string. Flags are defined in 5.6.2 Flags. The $flags argument is interpreted in the same manner as for the fn:matches function. The replacement string is determined by the values of the $replacement and/or $action arguments. If both these arguments are present and non-empty, an error is reported. If $value is the empty sequence, it is interpreted as the zero-length string.

The function returns the xs:string that is obtained by replacing each non-overlapping substring of $value that matches the given $pattern with a replacement string.

If two overlapping substrings of $value both match the $pattern, then only the first one (that is, the one whose first ·character· comes first in the $value string) is replaced. The replacement string is determined as follows: • If the $replacement argument is present and is not an empty sequence, then the value of $replacement. • If the $action argument is present and is not an empty sequence, then the string obtained by calling the $action function. The first argument to the $action function is the string to be replaced.

The second argument to the $action function is the sequence of captured substrings. The Nth item in this sequence is the substring captured by the Nth parenthesized sub-expression. If the Nth parenthesized sub-expression was not matched, the Nth item will be the zero-length string. Note that the rules for function coercion mean that the function actually supplied for the $action parameter may be an arity-1 function: the second argument does not need to be declared if it is not used.

If the function returns an empty sequence, then the replacement string is the zero-length string.

• If neither of the $replacement or $action arguments is present, or if both are empty, then the replacement string is the zero-length string.

If the q flag is present, or if the replacement string was obtained by calling the $action function, then the replacement string is used as is. Otherwise, within the replacement string, a variable $N may be used to refer to the substring captured by the Nth parenthesized sub-expression in the regular expression. For each match of the pattern, these variables are assigned the value of the content matched by the relevant sub-expression, and the modified replacement string is then substituted for the ·characters· in $value that matched the pattern. $0 refers to the substring captured by the regular expression as a whole.

More specifically, the rules are as follows, where S is the number of parenthesized sub-expressions in the regular expression, and N is the decimal number formed by taking all the digits that consecutively follow the $ character: 1. If N=0, then the variable is replaced by the substring matched by the regular expression as a whole. 2. If 1<=N<=S, then the variable is replaced by the substring captured by the Nth parenthesized sub-expression. If the Nth parenthesized sub-expression was not matched, then the variable is replaced by the zero-length string. 3. If S<N<=9, then the variable is replaced by the zero-length string. 4. Otherwise (if N>S and N>9), the last digit of N is taken to be a literal character to be included "as is" in the replacement string, and the rules are reapplied using the number N formed by stripping off this last digit. For example, if the replacement string is "$23" and there are 5 substrings, the result contains the value of the substring that matches the second sub-expression, followed by the digit 3.

Unless the q flag is used, a literal $ character within the replacement string must be written as \$, and a literal \ character must be written as \\.

If two alternatives within the pattern both match at the same position in the $input, then the match that is chosen is the one matched by the first alternative. For example:  fn:replace("abcd", "(ab)|(a)", "[1=$1][2=$2]") returns "[1=ab][2=]cd" Error Conditions A dynamic error is raised [err:FORX0002] if the value of $pattern is invalid according to the rules described in section 5.6.1 Regular expression syntax.

A dynamic error is raised [err:FORX0001] if the value of $flags is invalid according to the rules described in section 5.6.2 Flags. A dynamic error is raised [err:FORX0003] if the pattern matches a zero-length string, that is, if the expression fn:matches("",$pattern, $flags) returns true. It is not an error, however, if a captured substring is zero-length. In the absence of the q flag, a dynamic error is raised [err:FORX0004] if the value of $replacement contains a dollar sign ($) character that is not immediately followed by a digit 0-9 and not immediately preceded by a backslash (\). In the absence of the q flag, a dynamic error is raised [err:FORX0004] if the value of $replacement contains a backslash (\) character that is not part of a \\ pair, unless it is immediately followed by a dollar sign ($) character. A dynamic error is raised [err:FORX0005] if both the $replacement and $action arguments are supplied, and neither is an empty sequence. Notes If the input string contains no substring that matches the regular expression, the result of the function is a single string identical to the input string. Examples The expression fn:replace("abracadabra", "bra", "*") returns "a*cada*". The expression fn:replace("abracadabra", "a.*a", "*") returns "*". The expression fn:replace("abracadabra", "a.*?a", "*") returns "*c*bra". The expression fn:replace("abracadabra", "a", "") returns "brcdbr". The expression fn:replace("abracadabra", "a(.)", "a$1$1") returns "abbraccaddabbra". The expression fn:replace("AAAA", "A+", "b") returns "b". The expression fn:replace("AAAA", "A+?", "b") returns "bbbb". The expression fn:replace("darted", "^(.*?)d(.*)$", "$1c$2") returns "carted". (The first d is replaced.)

The expression fn:replace("abracadabra", "bra", action: ->{"*"}) returns "a*cada*".

The expression fn:replace("abracadabra", "bra", action: fn:upper-case#1) returns aBRAcadaBRA.

The expression fn:replace("Chapter 9", "[0-9]+", action: ->{string(number(.)+1)}) returns "Chapter 10".

The expression fn:replace("LHR to LAX", "[A-Z]{3}", action: map{'LAX': 'Los Angeles', 'LHR': 'London'}) returns "London to Los Angeles".

The expression fn:replace("57°43′30″", "([0-9]+)°([0-9]+)′([0-9]+)″)", action: ->($s,$groups){string(number($groups[1]) + number($groups[2])÷60 + number($groups[3])÷3600)||'°'}) returns "57.725°". The expression fn:replace("abracadabra", ".*?", "$1") raises an error, because the pattern matches the zero-length string

#### 5.6.5 fn:tokenize

Summary

Returns a sequence of strings constructed by splitting the input wherever a separator is found; the separator is any substring that matches a given regular expression.

Signatures
 fn:tokenize( $value as xs:string? ) as xs:string*  fn:tokenize( $value as xs:string?, $pattern as xs:string ) as xs:string*  fn:tokenize( $value as xs:string?, $pattern as xs:string, $flags as xs:string ) as xs:string*
Properties

This function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

The one-argument form of this function splits the supplied string at whitespace boundaries. More specifically, calling fn:tokenize($value) is equivalent to calling fn:tokenize(fn:normalize-space($value), ' ')) where the second argument is a single space character (x20).

The effect of calling the two-argument form of this function (omitting the argument $flags) is the same as the effect of calling the three-argument version with the $flags argument set to a zero-length string. Flags are defined in 5.6.2 Flags.

The following rules apply to the three-argument form of the function:

• The $flags argument is interpreted in the same way as for the fn:matches function. • If $value is the empty sequence, or if $value is the zero-length string, the function returns the empty sequence. • The function returns a sequence of strings formed by breaking the $value string into a sequence of strings, treating any substring that matches $pattern as a separator. The separators themselves are not returned. • Except with the one-argument form of the function, if a separator occurs at the start of the $value string, the result sequence will start with a zero-length string. Similarly, zero-length strings will also occur in the result sequence if a separator occurs at the end of the $value string, or if two adjacent substrings match the supplied $pattern.

• If two alternatives within the supplied $pattern both match at the same position in the $value string, then the match that is chosen is the first. For example:

 fn:tokenize("abracadabra", "(ab)|(a)") returns ("", "r", "c", "d", "r", "")
Error Conditions

A dynamic error is raised [err:FORX0002] if the value of $pattern is invalid according to the rules described in section 5.6.1 Regular expression syntax. A dynamic error is raised [err:FORX0001] if the value of $flags is invalid according to the rules described in section 5.6.2 Flags.

A dynamic error is raised [err:FORX0003] if the supplied $pattern matches a zero-length string, that is, if fn:matches("",$pattern, $flags) returns true. Notes If the input string is not zero length, and no separators are found in the input string, the result of the function is a single string identical to the input string. The one-argument form of the function has a similar effect to the two-argument form with \s+ as the separator pattern, except that the one-argument form strips leading and trailing whitespace, whereas the two-argument form delivers an extra zero-length token if leading or trailing whitespace is present. The function returns no information about the separators that were found in the string. If this information is required, the fn:analyze-string function can be used instead. The separator used by the one-argument form of the function is any sequence of tab (x09), newline (x0A), carriage return (x0D) or space (x20) characters. This is the same as the separator recognized by list-valued attributes as defined in XSD. It is not the same as the separator recognized by list-valued attributes in HTML5, which also treats form-feed (x0C) as whitespace. If it is necessary to treat form-feed as a separator, an explicit separator pattern should be used. Examples The expression fn:tokenize(" red green blue ") returns ("red", "green", "blue"). The expression fn:tokenize("The cat sat on the mat", "\s+") returns ("The", "cat", "sat", "on", "the", "mat"). The expression fn:tokenize(" red green blue ", "\s+") returns ("", "red", "green", "blue", ""). The expression fn:tokenize("1, 15, 24, 50", ",\s*") returns ("1", "15", "24", "50"). The expression fn:tokenize("1,15,,24,50,", ",") returns ("1", "15", "", "24", "50", ""). fn:tokenize("abba", ".?") raises the dynamic error [err:FORX0003]. The expression fn:tokenize("Some unparsed <br> HTML <BR> text", "\s*<br>\s*", "i") returns ("Some unparsed", "HTML", "text"). #### 5.6.6 fn:analyze-string Summary Analyzes a string using a regular expression, returning an XML structure that identifies which parts of the input string matched or failed to match the regular expression, and in the case of matched substrings, which substrings matched each capturing group in the regular expression. Signatures  fn:analyze-string( $value as xs:string?, $pattern as xs:string ) as element(fn:analyze-string-result)  fn:analyze-string( $value as xs:string?, $pattern as xs:string, $flags as xs:string ) as element(fn:analyze-string-result)
Properties

This function is ·nondeterministic·, ·context-independent·, and ·focus-independent·.

Rules

The effect of calling the first version of this function (omitting the argument $flags) is the same as the effect of calling the second version with the $flags argument set to a zero-length string. Flags are defined in 5.6.2 Flags.

The $flags argument is interpreted in the same way as for the fn:matches function. If $value is the empty sequence the function behaves as if $value were the zero-length string. In this situation the result will be an element node with no children. The function returns an element node whose local name is analyze-string-result. This element and all its descendant elements have the namespace URI http://www.w3.org/2005/xpath-functions. The namespace prefix is ·implementation-dependent·. The children of this element are a sequence of fn:match and fn:non-match elements. This sequence is formed by breaking the $value string into a sequence of strings, returning any substring that matches $pattern as the content of a match element, and any intervening substring as the content of a non-match element. More specifically, the function starts at the beginning of the input string and attempts to find the first substring that matches the regular expression. If there are several matches, the first match is defined to be the one whose starting position comes first in the string. If several alternatives within the regular expression both match at the same position in the input string, then the match that is chosen is the first alternative that matches. For example, if the input string is The quick brown fox jumps and the regular expression is jump|jumps, then the match that is chosen is jump. Having found the first match, the instruction proceeds to find the second and subsequent matches by repeating the search, starting at the first ·character· that was not included in the previous match. The input string is thus partitioned into a sequence of substrings, some of which match the regular expression, others which do not match it. Each substring will contain at least one character. This sequence is represented in the result by the sequence of fn:match and fn:non-match children of the returned element node; the string value of the fn:match or fn:non-match element will be the corresponding substring of $input, and the string value of the returned element node will therefore be the same as $input. The content of an fn:non-match element is always a single text node. The content of a fn:match element, however, is in general a sequence of text nodes and fn:group element children. An fn:group element with a nr attribute having the integer value N identifies the substring captured by the Nth parenthesized sub-expression in the regular expression. For each capturing subexpression there will be at most one corresponding fn:group element in each fn:match element in the result. If the function is called twice with the same arguments, it is ·implementation-dependent· whether the two calls return the same element node or distinct (but deep equal) element nodes. In this respect it is ·non-deterministic with respect to node identity·. The base URI of the element nodes in the result is ·implementation-dependent·. A schema is defined for the structure of the returned element: see C.1 Schema for the result of fn:analyze-string. The result of the function will always be such that validation against this schema would succeed. However, it is ·implementation-defined· whether the result is typed or untyped, that is, whether the elements and attributes in the returned tree have type annotations that reflect the result of validating against this schema. Error Conditions A dynamic error is raised [err:FORX0002] if the value of $pattern is invalid according to the rules described in section 5.6.1 Regular expression syntax.

A dynamic error is raised [err:FORX0001] if the value of $flags is invalid according to the rules described in section 5.6.2 Flags. A dynamic error is raised [err:FORX0003] if the supplied $pattern matches a zero-length string, that is, if fn:matches("", $pattern,$flags) returns true.

Notes

It is recommended that a processor that implements schema awareness should return typed nodes. The concept of "schema awareness", however, is a matter for host languages to define and is outside the scope of the function library specification.

The declarations and definitions in the schema are not automatically available in the static context of the fn:analyze-string call (or of any other expression). The contents of the static context are host-language defined, and in some host languages are implementation-defined.

The schema defines the outermost element, analyze-string-result, in such a way that mixed content is permitted. In fact the element will only have element nodes (match and non-match) as its children, never text nodes. Although this might have originally been an oversight, defining the analyze-string-result element with mixed="true" allows it to be atomized, which is potentially useful (the atomized value will be the original input string), and the capability has therefore been retained for compatibility with the 3.0 version of this specification.

Examples

In the following examples, the result document is shown in serialized form, with whitespace between the element nodes. This whitespace is not actually present in the result.

The expression fn:analyze-string("The cat sat on the mat.", "\w+") returns (with whitespace added for legibility):

<analyze-string-result xmlns="http://www.w3.org/2005/xpath-functions">
<match>The</match>
<non-match> </non-match>
<match>cat</match>
<non-match> </non-match>
<match>sat</match>
<non-match> </non-match>
<match>on</match>
<non-match> </non-match>
<match>the</match>
<non-match> </non-match>
<match>mat</match>
<non-match>.</non-match>
</analyze-string-result>

The expression fn:analyze-string("2008-12-03", "^(\d+)\-(\d+)\-(\d+)$") returns (with whitespace added for legibility): <analyze-string-result xmlns="http://www.w3.org/2005/xpath-functions"> <match><group nr="1">2008</group>-<group nr="2" >12</group>-<group nr="3">03</group></match> </analyze-string-result> The expression fn:analyze-string("A1,C15,,D24, X50,", "([A-Z])([0-9]+)") returns (with whitespace added for legibility): <analyze-string-result xmlns="http://www.w3.org/2005/xpath-functions"> <match><group nr="1">A</group><group nr="2">1</group></match> <non-match>,</non-match> <match><group nr="1">C</group><group nr="2">15</group></match> <non-match>,,</non-match> <match><group nr="1">D</group><group nr="2">24</group></match> <non-match>, </non-match> <match><group nr="1">X</group><group nr="2">50</group></match> <non-match>,</non-match> </analyze-string-result> ## 6 Functions that manipulate URIs This section specifies functions that manipulate URI values, either as instances of xs:anyURI or as strings. Function Meaning fn:resolve-uri Resolves a relative IRI reference against an absolute IRI. fn:encode-for-uri Encodes reserved characters in a string that is intended to be used in the path segment of a URI. fn:iri-to-uri Converts a string containing an IRI into a URI according to the rules of [RFC 3987]. fn:escape-html-uri Escapes a URI in the same way that HTML user agents handle attribute values expected to contain URIs. ### 6.1 fn:resolve-uri Summary Resolves a relative IRI reference against an absolute IRI. Signatures  fn:resolve-uri( $relative as xs:string? ) as xs:anyURI?
 fn:resolve-uri( $relative as xs:string?, $base as xs:string ) as xs:anyURI?
Properties

The one-argument form of this function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on static base URI.

The two-argument form of this function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

The function is defined to operate on IRI references as defined in [RFC 3987], and the implementation must permit all arguments that are valid according to that specification. In addition, the implementation may accept some or all strings that conform to the rules for (absolute or relative) Legacy Extended IRI references as defined in [Legacy extended IRIs for XML resource identification]. For the purposes of this section, the terms IRI and IRI reference include these extensions, insofar as the implementation chooses to support them.

The following rules apply in order:

1. If $relative is the empty sequence, the function returns the empty sequence. 2. If $relative is an absolute IRI (as defined above), then it is returned unchanged.

3. If the $base argument is not supplied, then: 1. If the static base URI in the static context is not absent, it is used as the effective value of $base.

2. Otherwise, a dynamic error is raised: .

4. The function resolves the relative IRI reference $relative against the base IRI $base using the algorithm defined in [RFC 3986], adapted by treating any ·character· that would not be valid in an RFC3986 URI or relative reference in the same way that RFC3986 treats unreserved characters. No percent-encoding takes place.

Error Conditions

The first form of this function resolves $relative against the value of the base-uri property from the static context. A dynamic error is raised [err:FONS0005] if the base-uri property is not initialized in the static context. A dynamic error is raised [err:FORG0002] if $relative is not a valid IRI according to the rules of RFC3987, extended with an implementation-defined subset of the extensions permitted in LEIRI, or if it is not a suitable relative reference to use as input to the RFC3986 resolution algorithm extended to handle additional unreserved characters.

A dynamic error is raised [err:FORG0002] if $base is not a valid IRI according to the rules of RFC3987, extended with an implementation-defined subset of the extensions permitted in LEIRI, or if it is not a suitable IRI to use as input to the chosen resolution algorithm (for example, if it is a relative IRI reference, if it is a non-hierarchic URI, or if it contains a fragment identifier). A dynamic error is raised [err:FORG0009] if the chosen resolution algorithm fails for any other reason. Notes Resolving a URI does not dereference it. This is merely a syntactic operation on two ·strings·. The algorithms in the cited RFCs include some variations that are optional or recommended rather than mandatory; they also describe some common practices that are not recommended, but which are permitted for backwards compatibility. Where the cited RFCs permit variations in behavior, so does this specification. Throughout this family of specifications, the phrase "resolving a relative URI (or IRI) reference" should be understood as using the rules of this function, unless otherwise stated. RFC3986 defines an algorithm for resolving relative references in the context of the URI syntax defined in that RFC. RFC3987 describes a modification to that algorithm to make it applicable to IRIs (specifically: additional characters permitted in an IRI are handled the same way that RFC3986 handles unreserved characters). The LEIRI specification does not explicitly define a resolution algorithm, but suggests that it should not be done by converting the LEIRI to a URI, and should not involve percent-encoding. This specification fills this gap by defining resolution for LEIRIs in the same way that RFC3987 defines resolution for IRIs, that is by specifying that additional characters are handled as unreserved characters. ### 6.2 fn:encode-for-uri Summary Encodes reserved characters in a string that is intended to be used in the path segment of a URI. Signature  fn:encode-for-uri( $value as xs:string? ) as xs:string
Properties

This function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

If $value is the empty sequence, the function returns the zero-length string. This function applies the URI escaping rules defined in section 2 of [RFC 3986] to the xs:string supplied as $value. The effect of the function is to escape reserved characters. Each such character in the string is replaced with its percent-encoded form as described in [RFC 3986].

Since [RFC 3986] recommends that, for consistency, URI producers and normalizers should use uppercase hexadecimal digits for all percent-encodings, this function must always generate hexadecimal values using the upper-case letters A-F.

Notes

All characters are escaped except those identified as "unreserved" by [RFC 3986], that is the upper- and lower-case letters A-Z, the digits 0-9, HYPHEN-MINUS ("-"), LOW LINE ("_"), FULL STOP ".", and TILDE "~".

This function escapes URI delimiters and therefore cannot be used indiscriminately to encode "invalid" characters in a path segment.

This function is invertible but not idempotent. This is because a string containing a percent character will be modified by applying the function: for example 100% becomes 100%25, while 100%25 becomes 100%2525.

Examples

The expression fn:encode-for-uri("http://www.example.com/00/Weather/CA/Los%20Angeles#ocean") returns "http%3A%2F%2Fwww.example.com%2F00%2FWeather%2FCA%2FLos%2520Angeles%23ocean". (This is probably not what the user intended because all of the delimiters have been encoded.)

The expression concat("http://www.example.com/", encode-for-uri("~bébé")) returns "http://www.example.com/~b%C3%A9b%C3%A9".

The expression concat("http://www.example.com/", encode-for-uri("100% organic")) returns "http://www.example.com/100%25%20organic".

### 6.3 fn:iri-to-uri

Summary

Converts a string containing an IRI into a URI according to the rules of [RFC 3987].

Signature
 fn:iri-to-uri( $value as xs:string? ) as xs:string Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the zero-length string.

Otherwise, the function converts $value into a URI according to the rules given in Section 3.1 of [RFC 3987] by percent-encoding characters that are allowed in an IRI but not in a URI. If $value contains a character that is invalid in an IRI, such as the space character (see note below), the invalid character is replaced by its percent-encoded form as described in [RFC 3986] before the conversion is performed.

Since [RFC 3986] recommends that, for consistency, URI producers and normalizers should use uppercase hexadecimal digits for all percent-encodings, this function must always generate hexadecimal values using the upper-case letters A-F.

Notes

The function is idempotent but not invertible. Both the inputs My Documents and My%20Documents will be converted to the output My%20Documents.

This function does not check whether $iri is a valid IRI. It treats it as an ·string· and operates on the ·characters· in the string. The following printable ASCII characters are invalid in an IRI: "<", ">", " " " (double quote), space, "{", "}", "|", "\", "^", and "". Since these characters should not appear in an IRI, if they do appear in $iri they will be percent-encoded. In addition, characters outside the range x20-x7E will be percent-encoded because they are invalid in a URI.

Since this function does not escape the PERCENT SIGN "%" and this character is not allowed in data within a URI, users wishing to convert character strings (such as file names) that include "%" to a URI should manually escape "%" by replacing it with "%25".

Examples

The expression fn:iri-to-uri ("http://www.example.com/00/Weather/CA/Los%20Angeles#ocean") returns "http://www.example.com/00/Weather/CA/Los%20Angeles#ocean".

The expression fn:iri-to-uri ("http://www.example.com/~bébé") returns "http://www.example.com/~b%C3%A9b%C3%A9".

### 6.4 fn:escape-html-uri

Summary

Escapes a URI in the same way that HTML user agents handle attribute values expected to contain URIs.

Signature
 fn:escape-html-uri( $value as xs:string? ) as xs:string Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the zero-length string.

Otherwise, the function escapes all ·characters· except printable characters of the US-ASCII coded character set, specifically the ·codepoints· between 32 and 126 (decimal) inclusive. Each character in $uri to be escaped is replaced by an escape sequence, which is formed by encoding the character as a sequence of octets in UTF-8, and then representing each of these octets in the form %HH, where HH is the hexadecimal representation of the octet. This function must always generate hexadecimal values using the upper-case letters A-F. Notes The behavior of this function corresponds to the recommended handling of non-ASCII characters in URI attribute values as described in [HTML 4.0] Appendix B.2.1. Examples The expression fn:escape-html-uri("http://www.example.com/00/Weather/CA/Los Angeles#ocean") returns "http://www.example.com/00/Weather/CA/Los Angeles#ocean". The expression fn:escape-html-uri("javascript:if (navigator.browserLanguage == 'fr') window.open('http://www.example.com/~bébé');") returns "javascript:if (navigator.browserLanguage == 'fr') window.open('http://www.example.com/~b%C3%A9b%C3%A9');". ### 6.5 Parsing and building URIs This section specifies functions that parse strings as URIs, to identify their structure, and construct URI strings from their structured representation. Function Meaning fn:parse-uri Parses the URI provided and returns a map of its parts. fn:build-uri Constructs a URI from the parts provided. The structured representation of a URI is described by the uri-structure-record:  †uri-structure-record: record( uri?  as xs:string, scheme?  as xs:string, authority?  as xs:string, userinfo?  as xs:string, host?  as xs:string, port?  as xs:string, path?  as xs:string, query?  as xs:string, fragment?  as xs:string, path-segments?  as array(xs:string), query-segments?  as array(record(key? as xs:string, value? as xs:string, *)), * ) The parts of this structure are:  uri The original URI. This element is returned by fn:parse-uri, but ignored by fn:build-uri. scheme The URI scheme (e.g., “https” or “file”). authority The authority portion of the URI (e.g., “example.com:8080”). userinfo Any userinfo that was passed as part of the authority. host The host passed as part of the authority (e.g., “example.com”). port The port passed as part of the authority (e.g., “8080”). path The path portion of the URI. query Any query string. fragment Any fragment identifier. path-segments Parsed and unescaped path segments. query-segments Parsed and unescaped query terms * Additional, information defined structures are allowed. The segmented forms of the path and query parameters provide convenient access to commonly used information. They’re represented in the map as arrays, instead of sequences, just for the convenience of serializing the structure. The path, if there is one, is tokenized on “/” characters and each segment is unesaped. Consider the URI http://example.com/path/to/a%2fb. The path portion has to be returned as /path/to/a%2fb because decoding the %2f would change the nature of the path. The unescaped form is easily accessible from the path-segments array: [ "", "path", "to", "a/b" ] Note that the presence or absence of a leading slash on the path will effect whether or not the array begins with an empty string. The query parameters are similarly decoded. Consider the URI: http://example.com/path?a=1&b=2%264&a=3. Here the decoded form in the query-segments gives quick access to the parameter values: [ { "key": "a", "value": "1" }, { "key": "b", "value": "2&4" }, { "key": "a", "value": "3" } ] Note that both keys and values are unescaped and that it’s an array of maps because key values can be repeated, as seen for a in this example. #### 6.5.1 fn:parse-uri Summary Parses the URI provided and returns a map of its parts. Signature  fn:parse-uri( $uri as xs:string, $options as map(*) := map{} ) as †uri-structure-record Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules The function parses the $uri provided, returning a map containing its constituent parts: scheme, authority components, path, etc. In addition to parsing URIs as defined by [RFC 3986] (and [RFC 3987]), this function also attempts to account for strings that are not valid URIs but that often appear in URI-adjacent spaces, such as file names.

This function is described as a series of transformations over the input string to identify the parts of a URI that are present. Some portions of the URI are identified by matching with a regular expression. This approach is designed to make the description clear and unambiguous, it is not implementation advice.

Begin with a string that is equal to the $uri. If the string contains any backlashes (“\”), replace them with forward slashes (“/”). If the string matches ^(.*)#([^#]*)$, the string is the first match group and the fragment is the second match group. Otherwise, the string is unchanged and the fragment is the empty sequence.

If the string matches ^(.*)\?([^\?]*)$, the string is the first match group and the query is the second match group. Otherwise, the string is unchanged and the query is the empty sequence. If the string matches ^[a-zA-Z]:, the scheme is file and the string is unchanged. Otherwise, if the string matches ^([a-zA-Z][A-Za-z0-9\+\-\.]*):(.*)$, the scheme is the first match group and the string is the second match group. If the string does not match either expression, the scheme is the empty sequence and the string is unchanged.

If the string matches ^//*([a-zA-Z]:.*)$, the authority is empty and the string is the first match group. Otherwise, if the string matches ^///*([^/]+)(/.*)?$ then the authority is the first match group and the string is the second match group. If the string does not match either regular expression, the authority is the empty sequence and the string is unchanged.

If the authority matches (([^@]*)@)(.*)(:([^:]*))?$, then the userinfo is match group 2, otherwise userinfo is the empty sequence. If the authority matches (([^@]*)@)?(.+)(:([^:]*))?$, then the host is match group 3, otherwise host is the empty sequence.

If the authority matches (([^@]*)@)?(.*)(:([^:]*))$, then the port is match group 5, otherwise port is the empty sequence. If the string is the empty string, then path is the empty sequence, otherwise the path is the whole string. If the $options map contains a key named “path-separator”, the value of that key is the path separator otherwise the separator is a single slash (“/”). It is a dynamic error XXXX if the key is present and it’s value is not a string of length one.

A path-segments array is constructed as follows: tokenize the string on the path separator, apply uri decoding on each token, and convert the result to an array.

Applying uri decoding replaces all occurrences of plus (“+”) with spaces and all occurrences of %[a-fA-F0-9][a-fA-F0-9] with a single character with the codepoint represented by the two digit hexadecimal number that follows the “%”. In other words, “A%42C” becomes “ABC”. If there are any occurrences of % followed by up to two characters that are not hexadecimal digits, they are replaced by the single character with the codepoint 0xfffd. In other words “A%XYC%Z” becomes “A�C�”.

If the $options map contains a key named “query-separator”, the value of that key is the query separator otherwise the separator is a single ampersand (“&”). It is a dynamic error XXXX if the key is present and it’s value is not a string of length one. A query-segments is constructed as follows: tokenize the query on the query separator. For each token, construct a map. If the token contains an equal sign (“=”), the map contains a key named key with a value equal to the string preceding the first equal sign and a key named value with a value equal to the string following the first equal sign. If the token does not contain an equal sign, the map contains a single key named value with a value equal to the token. In every case, uri decoding is applied to each value add to the map. The resulting sequence of maps is converted into an array. The following map is returned: { "uri":$uri,
"scheme": scheme,
"authority": authority,
"userinfo": userinfo,
"host": host,
"port": port,
"path": path,
"query": query,
"fragment": fragment,
"path-segments": path-segments,
"query-segments": query-segments
}

The map should only be populated with keys that have a non-empty value (keys who’s value is the empty sequence or an empty array should be omitted).

Implementations may implement additional or different rules for URIs that have a scheme or pattern that they recognize. An implementation might choose to parse jar: URIs with special rules, for example, since they extend the syntax in ways not defined by [RFC 3986]. Implementations may add additional keys to the map. The meaning of those keys is implementation-defined.

TODO: In order to better support implementation extensibility, should the keys in the map be QNames with the requirement that implementation-defined keys be in a non-empty namespace?

Error Conditions

An error is raised XXXX if the supplied path separator is not a single character.

An error is raised XXXX if the supplied query separator is not a single character.

Notes

Like fn:resolve-uri, this function handles the additional characters allowed in [RFC 3987] IRIs in the same way that other unreserved characters are handled.

Unlike fn:resolve-uri, this function is not attempting to resolve one URI against another and consequently, the errors that can arise under those circumstances do not apply here. The fn:parse-uri function will accept strings that would raise errors if resolution was attempted, see fn:build-uri.

Examples

In the examples that follow, keys with values that are null, or an empty array, are elided for editorial clarity.

The expression fn:parse-uri("http://qt4cg.org/specifications/xpath-functions-40/Overview.html#parse-uri") returns

map {
"uri": "http://qt4cg.org/specifications/xpath-functions-40/Overview.html#parse-uri",
"scheme": "http",
"authority": "qt4cg.org",
"host": "qt4cg.org",
"path": "/specifications/xpath-functions-40/Overview.html",
"fragment": "parse-uri",
"path-segments": array { "", "specifications", "xpath-functions-40", "Overview.html" }
}
.

The expression fn:parse-uri("http://www.ietf.org/rfc/rfc2396.txt") returns

map {
"uri": "http://www.ietf.org/rfc/rfc2396.txt",
"scheme": "http",
"authority": "www.ietf.org",
"host": "www.ietf.org",
"path": "/rfc/rfc2396.txt",
"path-segments": array { "", "rfc", "rfc2396.txt" }
}
.

The expression fn:parse-uri("https://example.com/path/to/file") returns

map {
"uri": "https://example.com/path/to/file",
"scheme": "https",
"authority": "example.com",
"host": "example.com",
"path": "/path/to/file",
"path-segments": array { "", "path", "to", "file" }
}
.

The expression fn:parse-uri("https://example.com:8080/path?s=%22hello world%22&sort=relevance") returns

map {
"uri": "https://example.com:8080/path?s=%22hello world%22&sort=relevance",
"scheme": "https",
"authority": "example.com:8080",
"host": "example.com",
"port": "080",
"path": "/path",
"query": "s=%22hello world%22&sort=relevance",
"query-segments": array {
map { "key": "s", "value": """hello world""" },
map { "key": "sort", "value": "relevance" }
},
"path-segments": array { "", "path" }
}
.

The expression fn:parse-uri("https://user@example.com/path/to/file") returns

map {
"uri": "https://user@example.com/path/to/file",
"scheme": "https",
"authority": "user@example.com",
"userinfo": "user",
"host": "example.com",
"path": "/path/to/file",
"path-segments": array { "", "path", "to", "file" }
}
.

The expression fn:parse-uri("ftp://ftp.is.co.za/rfc/rfc1808.txt") returns

map {
"uri": "ftp://ftp.is.co.za/rfc/rfc1808.txt",
"scheme": "ftp",
"authority": "ftp.is.co.za",
"host": "ftp.is.co.za",
"path": "/rfc/rfc1808.txt",
"path-segments": array { "", "rfc", "rfc1808.txt" }
}
.

The expression fn:parse-uri("file:////uncname/path/to/file") returns

map {
"uri": "file:////uncname/path/to/file",
"scheme": "file",
"authority": "uncname",
"host": "uncname",
"path": "/path/to/file",
"path-segments": array { "", "path", "to", "file" }
}
.

The expression fn:parse-uri("file:///c:/path/to/file") returns

map {
"uri": "file:///c:/path/to/file",
"scheme": "file",
"path": "c:/path/to/file",
"path-segments": array { "c:", "path", "to", "file" }
}
.

The expression fn:parse-uri("file:/C:/Program%20Files/test.jar") returns

map {
"uri": "file:/C:/Program%20Files/test.jar",
"scheme": "file",
"path": "C:/Program%20Files/test.jar",
"path-segments": array { "C:", "Program Files", "test.jar" }
}
.

The expression fn:parse-uri("file:\\c:\path\to\file") returns

map {
"uri": "file:\\c:\path\to\file",
"scheme": "file",
"path": "c:/path/to/file",
"path-segments": array { "c:", "path", "to", "file" }
}
.

The expression fn:parse-uri("file:\c:\path\to\file") returns

map {
"uri": "file:\c:\path\to\file",
"scheme": "file",
"path": "c:/path/to/file",
"path-segments": array { "c:", "path", "to", "file" }
}
.

The expression fn:parse-uri("c:\path\to\file") returns

map {
"uri": "c:\path\to\file",
"scheme": "file",
"path": "c:/path/to/file",
"path-segments": array { "c:", "path", "to", "file" }
}
.

The expression fn:parse-uri("/path/to/file") returns

map {
"uri": "/path/to/file",
"path": "/path/to/file",
"path-segments": array { "", "path", "to", "file" }
}
.

The expression fn:parse-uri("#testing") returns

map {
"uri": "#testing",
"path": "",
"fragment": "testing"
}
.

The expression fn:parse-uri("?q=1") returns

map {
"uri": "?q=1",
"path": "",
"query": "q=1",
"query-segments": array {
map { "key": "q", "value": "1" }
}
}
.

The expression fn:parse-uri("ldap://[2001:db8::7]/c=GB?objectClass?one") returns

map {
"uri": "ldap://[2001:db8::7]/c=GB?objectClass?one",
"scheme": "ldap",
"authority": "[2001:db8::7]",
"host": "[2001:db8::7]",
"path": "/c=GB",
"query": "objectClass?one",
"query-segments": array {
map { "value": "objectClass?one" }
},
"path-segments": array { "", "c=GB" }
}
.

The expression fn:parse-uri("mailto:John.Doe@example.com") returns

map {
"uri": "mailto:John.Doe@example.com",
"scheme": "mailto",
"path": "John.Doe@example.com",
"path-segments": array { "John.Doe@example.com" }
}
.

The expression fn:parse-uri("news:comp.infosystems.www.servers.unix") returns

map {
"uri": "news:comp.infosystems.www.servers.unix",
"scheme": "news",
"path": "comp.infosystems.www.servers.unix",
"path-segments": array { "comp.infosystems.www.servers.unix" }
}
.

The expression fn:parse-uri("tel:+1-816-555-1212") returns

map {
"uri": "tel:+1-816-555-1212",
"scheme": "tel",
"path": "+1-816-555-1212",
"path-segments": array { " 1-816-555-1212" }
}
.

The expression fn:parse-uri("telnet://192.0.2.16:80/") returns

map {
"uri": "telnet://192.0.2.16:80/",
"scheme": "telnet",
"authority": "92.0.2.16:80",
"host": "92.0.2.16",
"port": "0",
"path": "/",
"path-segments": array { "", "" }
}
.

The expression fn:parse-uri("urn:oasis:names:specification:docbook:dtd:xml:4.1.2") returns

map {
"uri": "urn:oasis:names:specification:docbook:dtd:xml:4.1.2",
"scheme": "urn",
"path": "oasis:names:specification:docbook:dtd:xml:4.1.2",
"path-segments": array { "oasis:names:specification:docbook:dtd:xml:4.1.2" }
}
.

The expression fn:parse-uri("tag:textalign.net,2015:ns") returns

map {
"uri": "tag:textalign.net,2015:ns",
"scheme": "tag",
"path": "textalign.net,2015:ns",
"path-segments": [ "textalign.net,2015:ns" ]
}

.

The expression fn:parse-uri("tag:jan@example.com,1999-01-31:my-uri") returns

map {
"uri": "tag:jan@example.com,1999-01-31:my-uri"
"scheme": "tag",
"path": "jan@example.com,1999-01-31:my-uri",
"path-segments": [ "jan@example.com,1999-01-31:my-uri" ],
}

.

This example uses the algorithm described above, not an algorithm that is specifically aware of the jar: scheme.

The expression fn:parse-uri("jar:file:/C:/Program%20Files/test.jar!/foo/bar") returns

map {
"uri": "jar:file:/C:/Program%20Files/test.jar!/foo/bar",
"scheme": "jar",
"path": "file:/C:/Program%20Files/test.jar!/foo/bar",
"path-segments": array { "file:", "C:", "Program Files", "test.jar!", "foo", "bar" }
}

.

This example demonstrates that parsing the URI treats non-URI characters in lexical IRIs as “unreserved characters”. The rationale for this is given in the description of fn:resolve-uri.

The expression fn:parse-uri("http://www.example.org/Dürst") returns

map {
"uri": "http://www.example.org/Dürst",
"scheme": "http",
"authority": "www.example.org",
"host": "www.example.org",
"path": "/Dürst",
"path-segments": [ "","Dürst" ]
}

.

This example demonstrates a non-standard query separator.

The expression  fn:parse-uri("https://example.com:8080/path?s=%22hello world%22;sort=relevance", map { "query-separator": ";" }) returns

map {
"uri": "https://example.com:8080/path?s=%22hello world%22;sort=relevance",
"scheme": "https",
"authority": "example.com:8080",
"host": "example.com",
"port": "080",
"path": "/path",
"query": "s=%22hello world%22;sort=relevance",
"query-segments": array {
map { "key": "s", "value": """hello world""" },
map { "key": "sort", "value": "relevance" }
},
"path-segments": array { "", "path" }
}
.

This example uses an invalid query separator so raises an error.

The expression fn:parse-uri("https://example.com:8080/path?s=%22hello world%22;;sort=relevance", map { "query-separator": ";;" }) raises error FOXX0000.

History

Proposed on 17 Oct 2022 to resolve issue #72. Accepted in principle on 15 Nov 2022, with some details still to be resolved.

#### 6.5.2 fn:build-uri

Summary

Constructs a URI from the parts provided.

Signature
 fn:build-uri( $parts as †uri-structure-record, $options as map(*) := map{} ) as xs:string
Properties

This function is ·deterministic·, ·context-dependent·, and ·focus-independent·.

Rules

A URI is composed from a scheme, authority, path, query, and fragment. These components are derived from the contents of the $parts map in the following way: If the scheme key is present in the map, the URI begins with the value of that key concatenated with //, otherwise it begins //. If any of userinfo, host, or port are present in the map, the following authority is added to the URI under construction: concat((if (exists($parts?userinfo)) then $parts?userinfo || "@" else ""),$host,
(if (exists($parts?port)) then ":" ||$parts?port else ""))

If none of userinfo, host, or port is present, and authority is present, the value of the authority key is added to the URI.

fn:not Returns true if the effective boolean value of $input is false, or false if it is true. #### 7.3.1 fn:boolean Summary Computes the effective boolean value of the sequence $input.

Signature
 fn:boolean( $input as item()* ) as xs:boolean Rules The function computes the effective boolean value of a sequence, defined according to the following rules. See also Section 2.4.3 Effective Boolean Value XP31. • If $input is the empty sequence, fn:boolean returns false.

• If $input is a sequence whose first item is a node, fn:boolean returns true. • If $input is a singleton value of type xs:boolean or a derived from xs:boolean, fn:boolean returns $input. • If $input is a singleton value of type xs:string or a type derived from xs:string, xs:anyURI or a type derived from xs:anyURI, or xs:untypedAtomic, fn:boolean returns false if the operand value has zero length; otherwise it returns true.

• If $input is a singleton value of any numeric type or a type derived from a numeric type, fn:boolean returns false if the operand value is NaN or is numerically equal to zero; otherwise it returns true. Error Conditions In all cases other than those listed above, fn:boolean raises a type error [err:FORG0006]. Notes The result of this function is not necessarily the same as $input cast as xs:boolean. For example, fn:boolean("false") returns the value true whereas "false" cast as xs:boolean (which can also be written xs:boolean("false")) returns false.

Examples
let $abc := ("a", "b", "") fn:boolean($abc) raises a type error [err:FORG0006].

The expression fn:boolean($abc[1]) returns true(). The expression fn:boolean($abc[0]) returns false().

The expression fn:boolean($abc[3]) returns false(). fn:boolean([]) raises a type error [err:FORG0006]. #### 7.3.2 fn:not Summary Returns true if the effective boolean value of $input is false, or false if it is true.

Signature
 fn:not( $input as item()* ) as xs:boolean Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules The value of $input is first reduced to an effective boolean value by applying the fn:boolean() function. The function returns true if the effective boolean value is false, or false if the effective boolean value is true.

Examples

The expression fn:not(fn:true()) returns false().

The expression fn:not(()) returns true().

The expression fn:not("false") returns false().

fn:not(1 to 10) raises a type error [err:FORG0006].

## 8 Functions and operators on durations

Operators are defined on the following type:

• xs:duration

and on the two defined subtypes (see 8.1 Two totally ordered subtypes of duration):

• xs:yearMonthDuration

• xs:dayTimeDuration

No ordering relation is defined on xs:duration values. Two xs:duration values may however be compared for equality.

Operations on durations (including equality comparison, casting to string, and extraction of components) all treat the duration as normalized. This means that the seconds and minutes components will always be less than 60, the hours component less than 24, and the months component less than 12. Thus, for example, a duration of 120 seconds always gives the same result as a duration of two minutes.

Conditions such as underflow and overflow may occur with arithmetic on durations: see 9.7.1 Limits and precision

Note:

This means that in practice, the information content of an xs:duration value can be reduced to an xs:integer number of months, and an xs:decimal number of seconds. For the two defined subtypes this is further simplified so that one of these two components is fixed at zero. Operations such as comparison of durations and arithmetic on durations can be expressed in terms of numeric operations applied to these two components.

### 8.1 Two totally ordered subtypes of duration

Two subtypes of xs:duration, namely xs:yearMonthDuration and xs:dayTimeDuration, are defined in [Schema 1.1 Part 2]. These types must be available in the data model whether or not the implementation supports other aspects of XSD 1.1.

The significance of these subtypes is that arithmetic and ordering become well defined; this is not the case for xs:duration values in general, because of the variable number of days in a month. For this reason, many of the functions and operators on durations require the arguments/operands to belong to these two subtypes.

### 8.2 Comparison operators on durations

Function Meaning
op:yearMonthDuration-less-than Returns true if $arg1 is a shorter duration than $arg2.
op:dayTimeDuration-less-than Returns true if $arg1 is a shorter duration than $arg2.
op:duration-equal Returns true if $arg1 and $arg2 are durations of the same length.

The following comparison operators are defined on the [XML Schema Part 2: Datatypes Second Edition] duration datatypes. Each operator takes two operands of the same type and returns an xs:boolean result. As discussed in [XML Schema Part 2: Datatypes Second Edition], the order relation on xs:duration is a partial order rather than a total order. For this reason, only equality is defined on xs:duration. A full complement of comparison and arithmetic functions are defined on the two subtypes of duration described in 8.1 Two totally ordered subtypes of duration which do have a total order.

#### 8.2.1 op:yearMonthDuration-less-than

Summary

Returns true if $arg1 is a shorter duration than $arg2.

Operator Mapping

Defines the semantics of the "lt" operator when applied to two xs:yearMonthDuration values. Also used in the definition of the "ge" operator.

Signature
 op:yearMonthDuration-less-than( $arg1 as xs:yearMonthDuration, $arg2 as xs:yearMonthDuration ) as xs:boolean
Rules

If the number of months in $arg1 is numerically less than the number of months in $arg2, the function returns true.

Otherwise, the function returns false.

Notes

Either or both durations may be negative.

#### 8.2.2 op:dayTimeDuration-less-than

Summary

Returns true if $arg1 is a shorter duration than $arg2.

Operator Mapping

Defines the semantics of the "lt" operator when applied to two xs:dayTimeDuration values. Also used in the definition of the "ge" operator.

Signature
 op:dayTimeDuration-less-than( $arg1 as xs:dayTimeDuration, $arg2 as xs:dayTimeDuration ) as xs:boolean
Rules

If the number of seconds in $arg1 is numerically less than the number of seconds in $arg2, the function returns true.

Otherwise, the function returns false.

Notes

Either or both durations may be negative

#### 8.2.3 op:duration-equal

Summary

Returns true if $arg1 and $arg2 are durations of the same length.

Operator Mapping

Defines the semantics of the "eq" operators when applied to two xs:duration values. Also used in the definition of the "ne" operator.

Signature
 op:duration-equal( $arg1 as xs:duration, $arg2 as xs:duration ) as xs:boolean
Rules

If the xs:yearMonthDuration components of $arg1 and $arg2 are equal and the xs:dayTimeDuration components of $arg1 and $arg2 are equal, the function returns true.

Otherwise, the function returns false.

The semantics of this function are:

xs:yearMonthDuration($arg1) div xs:yearMonthDuration('P1M') eq xs:yearMonthDuration($arg2) div xs:yearMonthDuration('P1M')
and
xs:dayTimeDuration($arg1) div xs:dayTimeDuration('PT1S') eq xs:dayTimeDuration($arg2) div xs:dayTimeDuration('PT1S')


that is, the function returns true if the months and seconds values of the two durations are equal.

Notes

Note that this function, like any other, may be applied to arguments that are derived from the types given in the function signature, including the two subtypes xs:dayTimeDuration and xs:yearMonthDuration. With the exception of the zero-length duration, no instance of xs:dayTimeDuration can ever be equal to an instance of xs:yearMonthDuration.

Examples

The expression op:duration-equal(xs:duration("P1Y"), xs:duration("P12M")) returns true().

The expression op:duration-equal(xs:duration("PT24H"), xs:duration("P1D")) returns true().

The expression op:duration-equal(xs:duration("P1Y"), xs:duration("P365D")) returns false().

The expression op:duration-equal(xs:yearMonthDuration("P0Y"), xs:dayTimeDuration("P0D")) returns true().

The expression op:duration-equal(xs:yearMonthDuration("P1Y"), xs:dayTimeDuration("P365D")) returns false().

The expression op:duration-equal(xs:yearMonthDuration("P2Y"), xs:yearMonthDuration("P24M")) returns true().

The expression op:duration-equal(xs:dayTimeDuration("P10D"), xs:dayTimeDuration("PT240H")) returns true().

The expression op:duration-equal(xs:duration("P2Y0M0DT0H0M0S"), xs:yearMonthDuration("P24M")) returns true().

The expression op:duration-equal(xs:duration("P0Y0M10D"), xs:dayTimeDuration("PT240H")) returns true().

### 8.3 Component extraction functions on durations

The duration datatype may be considered to be a composite datatypes in that it contains distinct properties or components. The extraction functions specified below extract a single component from a duration value. For xs:duration and its subtypes, including the two subtypes xs:yearMonthDuration and xs:dayTimeDuration, the components are normalized: this means that the seconds and minutes components will always be less than 60, the hours component less than 24, and the months component less than 12.

Function Meaning
fn:years-from-duration Returns the number of years in a duration.
fn:months-from-duration Returns the number of months in a duration.
fn:days-from-duration Returns the number of days in a duration.
fn:hours-from-duration Returns the number of hours in a duration.
fn:minutes-from-duration Returns the number of minutes in a duration.
fn:seconds-from-duration Returns the number of seconds in a duration.

#### 8.3.1 fn:years-from-duration

Summary

Returns the number of years in a duration.

Signature
 fn:years-from-duration( $value as xs:duration? ) as xs:integer? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the empty sequence.

Otherwise, the function returns an xs:integer representing the years component in $value. Given that a duration is a ($months, $seconds) tuple, the result is the value of ($months idiv 12).

If $value is a negative duration then the result will be negative. If $value is an xs:dayTimeDuration the function returns 0.

Examples

The expression fn:years-from-duration(xs:yearMonthDuration("P20Y15M")) returns 21.

The expression fn:years-from-duration(xs:yearMonthDuration("-P15M")) returns -1.

The expression fn:years-from-duration(xs:dayTimeDuration("-P2DT15H")) returns 0.

#### 8.3.2 fn:months-from-duration

Summary

Returns the number of months in a duration.

Signature
 fn:months-from-duration( $value as xs:duration? ) as xs:integer? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the empty sequence.

Otherwise, the function returns an xs:integer representing the months component in $value. Given that a duration is a ($months, $seconds) tuple, the result is the value of ($months mod 12).

If $value is a negative duration then the result will be negative. If $value is an xs:dayTimeDuration the function returns 0.

Examples

The expression fn:months-from-duration(xs:yearMonthDuration("P20Y15M")) returns 3.

The expression fn:months-from-duration(xs:yearMonthDuration("-P20Y18M")) returns -6.

The expression fn:months-from-duration(xs:dayTimeDuration("-P2DT15H0M0S")) returns 0.

#### 8.3.3 fn:days-from-duration

Summary

Returns the number of days in a duration.

Signature
 fn:days-from-duration( $value as xs:duration? ) as xs:integer? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the empty sequence.

Otherwise, the function returns an xs:integer representing the days component in $value. Given that a duration is a ($months, $seconds) tuple, the result is ($seconds idiv 86400).

If $value is a negative duration then the result will be negative. If $value is an xs:yearMonthDuration the function returns 0.

Examples

The expression fn:days-from-duration(xs:dayTimeDuration("P3DT10H")) returns 3.

The expression fn:days-from-duration(xs:dayTimeDuration("P3DT55H")) returns 5.

The expression fn:days-from-duration(xs:yearMonthDuration("P3Y5M")) returns 0.

#### 8.3.4 fn:hours-from-duration

Summary

Returns the number of hours in a duration.

Signature
 fn:hours-from-duration( $value as xs:duration? ) as xs:integer? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the empty sequence.

Otherwise, the function returns an xs:integer representing the hours component in $value. Given that a duration is a ($months, $seconds) tuple, the result is the value of ($seconds mod 86400) idiv 3600.

If $value is a negative duration then the result will be negative. If $value is an xs:yearMonthDuration the function returns 0.

Examples

The expression fn:hours-from-duration(xs:dayTimeDuration("P3DT10H")) returns 10.

The expression fn:hours-from-duration(xs:dayTimeDuration("P3DT12H32M12S")) returns 12.

The expression fn:hours-from-duration(xs:dayTimeDuration("PT123H")) returns 3.

The expression fn:hours-from-duration(xs:dayTimeDuration("-P3DT10H")) returns -10.

#### 8.3.5 fn:minutes-from-duration

Summary

Returns the number of minutes in a duration.

Signature
 fn:minutes-from-duration( $value as xs:duration? ) as xs:integer? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the empty sequence.

Otherwise, the function returns an xs:integer representing the minutes component in $value. Given that a duration is a ($months, $seconds) tuple, the result is the value of ($seconds mod 3600) idiv 60.

If $value is a negative duration then the result will be negative. If $value is an xs:yearMonthDuration the function returns 0.

Examples

The expression fn:minutes-from-duration(xs:dayTimeDuration("P3DT10H")) returns 0.

The expression fn:minutes-from-duration(xs:dayTimeDuration("-P5DT12H30M")) returns -30.

#### 8.3.6 fn:seconds-from-duration

Summary

Returns the number of seconds in a duration.

Signature
 fn:seconds-from-duration( $value as xs:duration? ) as xs:decimal? Properties This function is ·deterministic·, ·context-independent·, and ·focus-independent·. Rules If $value is the empty sequence, the function returns the empty sequence.

Otherwise, the function returns an xs:decimal representing the seconds component in $value. Given that a duration is a ($months, $seconds) tuple, the result is the value of ($seconds mod 60) as an xs:decimal.

If $value is a negative duration then the result will be negative. If $value is an xs:yearMonthDuration the function returns 0.

Examples

The expression fn:seconds-from-duration(xs:dayTimeDuration("P3DT10H12.5S")) returns 12.5.

The expression fn:seconds-from-duration(xs:dayTimeDuration("-PT256S")) returns -16.0.

### 8.4 Arithmetic operators on durations

Function Meaning
op:add-yearMonthDurations Returns the result of adding two xs:yearMonthDuration values.
op:subtract-yearMonthDurations Returns the result of subtracting one xs:yearMonthDuration value from another.
op:multiply-yearMonthDuration Returns the result of multiplying $arg1 by $arg2. The result is rounded to the nearest month.
op:divide-yearMonthDuration Returns the result of dividing $arg1 by $arg2. The result is rounded to the nearest month.
op:divide-yearMonthDuration-by-yearMonthDuration Returns the ratio of two xs:yearMonthDuration values.
op:add-dayTimeDurations Returns the sum of two xs:dayTimeDuration values.
op:subtract-dayTimeDurations Returns the result of subtracting one xs:dayTimeDuration from another.
op:multiply-dayTimeDuration Returns the result of multiplying a xs:dayTimeDuration by a number.
op:divide-dayTimeDuration Returns the result of multiplying a xs:dayTimeDuration by a number.
op:divide-dayTimeDuration-by-dayTimeDuration Returns the ratio of two xs:dayTimeDuration values, as a decimal number.

For operators that combine a duration and a date/time value, see 9.7 Arithmetic operators on durations, dates and times.

Summary

Returns the result of adding two xs:yearMonthDuration values.

Operator Mapping

Defines the semantics of the "+" operator when applied to two xs:yearMonthDuration values.

Signature
 op:add-yearMonthDurations( $arg1 as xs:yearMonthDuration, $arg2 as xs:yearMonthDuration ) as xs:yearMonthDuration
Rules

The function returns the result of adding $arg1 to $arg2. The result will be an xs:yearMonthDuration whose length in months is equal to the length in months of $arg1 plus the length in months of $arg2.

For handling of overflow, see 9.7.1 Limits and precision.

Notes

Either duration (and therefore the result) may be negative.

Examples

The expression op:add-yearMonthDurations(xs:yearMonthDuration("P2Y11M"), xs:yearMonthDuration("P3Y3M")) returns xs:yearMonthDuration("P6Y2M").

#### 8.4.2 op:subtract-yearMonthDurations

Summary

Returns the result of subtracting one xs:yearMonthDuration value from another.

Operator Mapping

Defines the semantics of the "-" operator when applied to two xs:yearMonthDuration values.

Signature
 op:subtract-yearMonthDurations( $arg1 as xs:yearMonthDuration, $arg2 as xs:yearMonthDuration ) as xs:yearMonthDuration
Rules

The function returns the result of subtracting $arg2 from $arg1. The result will be an xs:yearMonthDuration whose length in months is equal to the length in months of $arg1 minus the length in months of $arg2.

For handling of overflow, see 9.7.1 Limits and precision.

Notes

Either duration (and therefore the result) may be negative.

Examples

The expression op:subtract-yearMonthDurations(xs:yearMonthDuration("P2Y11M"), xs:yearMonthDuration("P3Y3M")) returns xs:yearMonthDuration("-P4M").

#### 8.4.3 op:multiply-yearMonthDuration

Summary

Returns the result of multiplying $arg1 by $arg2. The result is rounded to the nearest month.

Operator Mapping

Defines the semantics of the "*" operator when applied to an xs:yearMonthDuration and a numeric value.

Signature
 op:multiply-yearMonthDuration( $arg1 as xs:yearMonthDuration, $arg2 as xs:double ) as xs:yearMonthDuration
Rules

The result is the xs:yearMonthDuration whose length in months is equal to the result of applying the fn:round function to the value obtained by multiplying the length in months of $arg1 by the value of $arg2.

If $arg2 is positive or negative zero, the result is a zero-length duration. If $arg2 is positive or negative infinity, the result overflows and is handled as described in 9.7.1 Limits and precision.

For handling of overflow and underflow, see 9.7.1 Limits and precision.

Error Conditions

A dynamic error is raised [err:FOCA0005] if $arg2 is NaN. Notes Either duration (and therefore the result) may be negative. Examples The expression op:multiply-yearMonthDuration(xs:yearMonthDuration("P2Y11M"), 2.3) returns xs:yearMonthDuration("P6Y9M"). #### 8.4.4 op:divide-yearMonthDuration Summary Returns the result of dividing $arg1 by $arg2. The result is rounded to the nearest month. Operator Mapping Defines the semantics of the "div" operator when applied to an xs:yearMonthDuration and a numeric value. Signature  op:divide-yearMonthDuration( $arg1 as xs:yearMonthDuration, $arg2 as xs:double ) as xs:yearMonthDuration Rules The result is the xs:yearMonthDuration whose length in months is equal to the result of applying the fn:round function to the value obtained by dividing the length in months of $arg1 by the value of $arg2. If $arg2 is positive or negative infinity, the result is a zero-length duration. If $arg2 is positive or negative zero, the result overflows and is handled as described in 9.7.1 Limits and precision. For handling of overflow and underflow, see 9.7.1 Limits and precision. Error Conditions A dynamic error is raised [err:FOCA0005] if $arg2 is NaN.

Notes

Either operand (and therefore the result) may be negative.

Examples

The expression op:divide-yearMonthDuration(xs:yearMonthDuration("P2Y11M"), 1.5) returns xs:yearMonthDuration("P1Y11M").

#### 8.4.5 op:divide-yearMonthDuration-by-yearMonthDuration

Summary

Returns the ratio of two xs:yearMonthDuration values.

Operator Mapping

Defines the semantics of the "div" operator when applied to two xs:yearMonthDuration values.

Signature
 op:divide-yearMonthDuration-by-yearMonthDuration( $arg1 as xs:yearMonthDuration, $arg2 as xs:yearMonthDuration ) as xs:decimal
Rules

The function returns the result of dividing the length in months of $arg1 by the length in months of $arg2, according to the rules of the op:numeric-divide function for integer operands.

For handling of overflow and underflow, see 9.7.1 Limits and precision.

Notes

Either duration (and therefore the result) may be negative.

Examples

The expression op:divide-yearMonthDuration-by-yearMonthDuration(xs:yearMonthDuration("P3Y4M"), xs:yearMonthDuration("-P1Y4M")) returns -2.5.

The following example demonstrates how to calculate the length of an xs:yearMonthDuration value in months:

The expression op:divide-yearMonthDuration-by-yearMonthDuration(xs:yearMonthDuration("P3Y4M"), xs:yearMonthDuration("P1M")) returns 40.

Summary

Returns the sum of two xs:dayTimeDuration values.

Operator Mapping

Defines the semantics of the "+" operator when applied to two xs:dayTimeDuration values.

Signature
 op:add-dayTimeDurations( $arg1 as xs:dayTimeDuration, $arg2 as xs:dayTimeDuration ) as xs:dayTimeDuration
Rules

The function returns the result of adding $arg1 to $arg2. The result is the xs:dayTimeDuration whose length in seconds is equal to the sum of the length in seconds of the two input durations.

For handling of overflow, see 9.7.1 Limits and precision.

Notes

Either duration (and therefore the result) may be negative.

Examples

The expression op:add-dayTimeDurations(xs:dayTimeDuration("P2DT12H5M"), xs:dayTimeDuration("P5DT12H")) returns xs:dayTimeDuration('P8DT5M').

#### 8.4.7 op:subtract-dayTimeDurations

Summary

Returns the result of subtracting one xs:dayTimeDuration from another.

Operator Mapping

Defines the semantics of the "-" operator when applied to two xs:dayTimeDuration values.

Signature
 op:subtract-dayTimeDurations( $arg1 as xs:dayTimeDuration, $arg2 as xs:dayTimeDuration ) as xs:dayTimeDuration
Rules

The function returns the result of subtracting $arg2 from $arg1. The result is the xs:dayTimeDuration whose length in seconds is equal to the length in seconds of $arg1 minus the length in seconds of $arg2.

For handling of overflow, see 9.7.1 Limits and precision.

Notes

Either duration (and therefore the result) may be negative.

Examples

The expression op:subtract-dayTimeDurations(xs:dayTimeDuration("P2DT12H"), xs:dayTimeDuration("P1DT10H30M")) returns xs:dayTimeDuration('P1DT1H30M').

#### 8.4.8 op:multiply-dayTimeDuration

Summary

Returns the result of multiplying a xs:dayTimeDuration by a number.

Operator Mapping

Defines the semantics of the "*" operator when applied to an xs:dayTimeDuration and a numeric value.

Signature
 op:multiply-dayTimeDuration( $arg1 as xs:dayTimeDuration, $arg2 as xs:double ) as xs:dayTimeDuration
Rules

The function returns the result of multiplying $arg1 by $arg2. The result is the xs:dayTimeDuration whose length in seconds is equal to the length in seconds of $arg1 multiplied by the numeric value $arg2.

If $arg2 is positive or negative zero, the result is a zero-length duration. If $arg2 is positive or negative infinity, the result overflows and is handled as described in 9.1.1 Limits and precision.

For handling of overflow and underflow, see 9.7.1 Limits and precision.

Error Conditions

A dynamic error is raised [err:FOCA0005] if $arg2 is NaN. Notes Either operand (and therefore the result) may be negative. Examples The expression op:multiply-dayTimeDuration(xs:dayTimeDuration("PT2H10M"), 2.1) returns xs:dayTimeDuration('PT4H33M'). #### 8.4.9 op:divide-dayTimeDuration Summary Returns the result of multiplying a xs:dayTimeDuration by a number. Operator Mapping Defines the semantics of the "div" operator when applied to two xs:dayTimeDuration values. Signature  op:divide-dayTimeDuration( $arg1 as xs:dayTimeDuration, $arg2 as xs:double ) as xs:dayTimeDuration Rules The function returns the result of dividing $arg1 by $arg2. The result is the xs:dayTimeDuration whose length in seconds is equal to the length in seconds of $arg1 divided by the numeric value $arg2. If $arg2 is positive or negative infinity, the result is a zero-length duration. If $arg2 is positive or negative zero, the result overflows and is handled as described in 9.1.1 Limits and precision. For handling of overflow and underflow, see 9.7.1 Limits and precision. Error Conditions A dynamic error is raised [err:FOCA0005] if $arg2 is NaN.

Notes

Either operand (and therefore the result) may be negative.

Examples

The expression op:divide-dayTimeDuration(xs:dayTimeDuration("P1DT2H30M10.5S"), 1.5) returns xs:duration("PT17H40M7S").

#### 8.4.10 op:divide-dayTimeDuration-by-dayTimeDuration

Summary

Returns the ratio of two xs:dayTimeDuration values, as a decimal number.

Operator Mapping

Defines the semantics of the "div" operator when applied to two xs:dayTimeDuration values.

Signature
 op:divide-dayTimeDuration-by-dayTimeDuration( $arg1 as xs:dayTimeDuration, $arg2 as xs:dayTimeDuration ) as xs:decimal
Rules

The function returns the result of dividing $arg1 by $arg2. The result is the xs:dayTimeDuration whose length in seconds is equal to the length in seconds of $arg1 divided by the length in seconds of $arg2. The calculation is performed by applying op:numeric-divide to the two xs:decimal operands.

For handling of overflow and underflow, see 9.7.1 Limits and precision.

Notes

Either operand (and therefore the result) may be negative.

Examples

The expression fn:round-half-to-even( op:divide-dayTimeDuration-by-dayTimeDuration( xs:dayTimeDuration("P2DT53M11S"), xs:dayTimeDuration("P1DT10H")), 4) returns 1.4378.

This examples shows how to determine the number of seconds in a duration.

The expression op:divide-dayTimeDuration-by-dayTimeDuration(xs:dayTimeDuration("P2DT53M11S"), xs:dayTimeDuration("PT1S")) returns 175991.0.

## 9 Functions and operators on dates and times

This section defines operations on the [XML Schema Part 2: Datatypes Second Edition] date and time types.

See [Working With Timezones] for a disquisition on working with date and time values with and without timezones.

### 9.1 Date and time types

The operators described in this section are defined on the following date and time types:

• xs:dateTime

• xs:date

• xs:time

• xs:gYearMonth

• xs:gYear

• xs:gMonthDay

• xs:gMonth

• xs:gDay

The only operation defined on xs:gYearMonth, xs:gYear, xs:gMonthDay, xs:gMonth and xs:gDay values is equality comparison. For other types, further operations are provided, including component extraction, order comparisons, arithmetic, formatted display, and timezone adjustment.

#### 9.1.1 Limits and precision

All minimally conforming processors must support positive year values with a minimum of 4 digits (i.e., YYYY) and a minimum fractional second precision of 1 millisecond or three digits (i.e., s.sss). However, conforming processors may set larger ·implementation-defined· limits on the maximum number of digits they support in these two situations. Processors may also choose to support the year 0000 and years with negative values. The results of operations on dates that cross the year 0000 are ·implementation-defined·.

A processor that limits the number of digits in date and time datatype representations may encounter overflow and underflow conditions when it tries to execute the functions in 9.7 Arithmetic operators on durations, dates and times. In these situations, the processor must return 00:00:00 in case of time underflow. It must raise a dynamic error [err:FODT0001] in case of overflow.

### 9.2 Date/time datatype values

As defined in Section 3.3.2 Dates and Times DM31, xs:dateTime, xs:date, xs:time, xs:gYearMonth, xs:gYear, xs:gMonthDay, xs:gMonth, xs:gDay values, referred to collectively as date/time values, are represented as seven components or properties: year, month, day, hour, minute, second and timezone. The first five components are xs:integer values. The value of the second component is an xs:decimal and the value of the timezone component is an xs:dayTimeDuration. For all the primitive date/time datatypes, the timezone property is optional and may or may not be present. Depending on the datatype, some of the remaining six properties must be present and some must be absentDM31. Absent, or missing, properties are represented by the empty sequence. This value is referred to as the local value in that the value retains its original timezone. Before comparing or subtracting xs:dateTime values, this local value must be translated or normalized to UTC.

For xs:time, 00:00:00 and 24:00:00 are alternate lexical forms for the same value, whose canonical representation is 00:00:00. For xs:dateTime, a time component 24:00:00 translates to 00:00:00 of the following day.

#### 9.2.1 Examples

• An xs:dateTime with lexical representation 1999-05-31T05:00:00 is represented in the datamodel by {1999, 5, 31, 5, 0, 0.0, ()}.

• An xs:dateTime with lexical representation 1999-05-31T13:20:00-05:00 is represented by {1999, 5, 31, 13, 20, 0.0, -PT5H}.

• An xs:dateTime with lexical representation 1999-12-31T24:00:00 is represented by {2000, 1, 1, 0, 0, 0.0, ()}.

• An xs:date with lexical representation 2005-02-28+8:00 is represented by {2005, 2, 28, (), (), (), PT8H}.

• An xs:time with lexical representation 24:00:00 is represented by {(), (), (), 0, 0, 0, ()}.

### 9.3 Constructing a dateTime

A function is provided for constructing a xs:dateTime value from a xs:date value and a xs:time value.

Function Meaning
fn:dateTime Returns an xs:dateTime value created by combining an xs:date and an xs:time.

#### 9.3.1 fn:dateTime

Summary

Returns an xs:dateTime value created by combining an xs:date and an xs:time.

Signature
 fn:dateTime( $date as xs:date?, $time as xs:time? ) as xs:dateTime?
Properties

This function is ·deterministic·, ·context-independent·, and ·focus-independent·.

Rules

If either $date or $time is the empty sequence the function returns the empty sequence.

Otherwise, the function returns an xs:dateTime whose date component is equal to $date and whose time component is equal to $time.

The timezone of the result is computed as follows:

• If neither argument has a timezone, the result has no timezone.

• If exactly one of the arguments has a timezone, or if both arguments have the same timezone, the result has this timezone.

Error Conditions

A dynamic error is raised [err:FORG0008] if the two arguments both have timezones and the timezones are different.

Examples

The expression fn:dateTime(xs:date("1999-12-31"), xs:time("12:00:00")) returns xs:dateTime("1999-12-31T12:00:00").

The expression fn:dateTime(xs:date("1999-12-31"), xs:time("24:00:00")) returns xs:dateTime("1999-12-31T00:00:00"). (This is because "24:00:00" is an alternate lexical form for "00:00:00").

### 9.4 Comparison operators on duration, date and time values

Function Meaning
op:dateTime-equal Returns true if the two supplied xs:dateTime values refer to the same instant in time.
op:dateTime-less-than Returns true if the first argument represents an earlier instant in time than the second argument.
op:date-equal Returns true if and only if the starting instants of the two supplied xs:date values are the same.
op:date-less-than Returns true if and only if the starting instant of $arg1 is less than the starting instant of $arg2. Returns false otherwise.
op:time-equal Returns true if the two xs:time values represent the same instant in time, when treated as being times on the same date, before adjusting the timezone.
op:time-less-than Returns true if the first xs:time value represents an earlier instant in time than the second, when both are treated as being times on the same date, before adjusting the timezone.
op:gYearMonth-equal Returns true if the two xs:gYearMonth values have the same starting instant.
op:gYear-equal Returns true if the two xs:gYear values have the same starting instant.
op:gMonthDay-equal Returns true if the two xs:gMonthDay values have the same starting instant, when considered as days in the same year.
op:gMonth-equal Returns true if the two xs:gMonth values have the same starting instant, when considered as months in the same year.
op:gDay-equal Returns true if the two xs:gDay values have the same starting instant, when considered as days in the same month of the same year.

The following comparison operators are defined on the [XML Schema Part 2: Datatypes Second Edition] date/time datatypes. Each operator takes two operands of the same type and returns an xs:boolean result.

[XML Schema Part 2: Datatypes Second Edition] also states that the order relation on date and time datatypes is not a total order but a partial order because these datatypes may or may not have a timezone. This is handled as follows. If either operand to a comparison function on date or time values does not have an (explicit) timezone then, for the purpose of the operation, an implicit timezone, provided by the dynamic context Section C.2 Dynamic Context Components XP31, is assumed to be present as part of the value. This creates a total order for all date and time values.

An xs:dateTime can be considered to consist of seven components: year, month, day, hour, minute, second and timezone. For xs:dateTime six components (year, month, day, hour, minute and second) are required and timezone is optional. For other date/time values, of the first six components, some are required and others must be absentDM31. Timezone is always optional. For example, for xs:date, the year, month and day components are required and hour, minute and second components must be absent; for xs:time the hour, minute and second components are required and year, month and day are missing; for xs:gDay, day is required and year, month, hour, minute and second are missing.

Note:

In [Schema 1.1 Part 2], a new explicitTimezone facet is available with values optional, required, or prohibited to enable the timezone to be defined as mandatory or disallowed.

Values of the date/time datatypes xs:time, xs:gMonthDay, xs:gMonth, and xs:gDay, can be considered to represent a sequence of recurring time instants or time periods. An xs:time occurs every day. An xs:gMonth occurs every year. Comparison operators on these datatypes compare the starting instants of equivalent occurrences in the recurring series. These xs:dateTime values are calculated as described below.

Comparison operators on xs:date, xs:gYearMonth and xs:gYear compare their starting instants. These xs:dateTime values are calculated as described below.

The starting instant of an occurrence of a date/time value is an xs:dateTime calculated by filling in the missing components of the local value from a reference xs:dateTime. An example of a suitable reference xs:dateTime is 1972-01-01T00:00:00. Then, for example, the starting instant corresponding to the xs:date value 2009-03-12 is 2009-03-12T00:00:00; the starting instant corresponding to the xs:time value 13:30:02 is 1972-01-01T13:30:02; and the starting instant corresponding to the gMonthDay value --02-29 is 1972-02-29T00:00:00 (which explains why a leap year was chosen for the reference).

Note:

In the previous version of this specification, the reference date/time chosen was 1972-12-31T00:00:00. While this gives the same results, it produces a "starting instant" for a gMonth or gMonthDay that bears no relation to the ordinary meaning of the term, and it also required special handling of short months. The original choice was made to allow for leap seconds; but since leap seconds are not recognized in date/time arithmetic, this is not actually necessary.

If the xs:time value written as 24:00:00 is to be compared, filling in the missing components gives 1972-01-01T00:00:00, because 24:00:00 is an alternative representation of 00:00:00 (the lexical value "24:00:00" is converted to the time components {0,0,0} before the missing components are filled in). This has the consequence that when ordering xs:time values, 24:00:00 is considered to be earlier than 23:59:59. However, when ordering xs:dateTime values, a time component of 24:00:00 is considered equivalent to 00:00:00 on the following day.

Note that the reference xs:dateTime does not have a timezone. The timezone component is never filled in from the reference xs:dateTime. In some cases, if the date/time value does not have a timezone, the implicit timezone from the dynamic context is used as the timezone.

Note:

This specification uses the reference xs:dateTime 1972-01-01T00:00:00 in the description of the comparison operators. Implementations may use other reference xs:dateTime values as long as they yield the same results. The reference xs:dateTime used must meet the following constraints: when it is used to supply components into xs:gMonthDay values, the year must allow for February 29 and so must be a leap year; when it is used to supply missing components into xs:gDay values, the month must allow for 31 days. Different reference xs:dateTime values may be used for different operators.

#### 9.4.1 op:dateTime-equal

Summary

Returns true if the two supplied xs:dateTime values refer to the same instant in time.

Operator Mapping

Defines the semantics of the "eq" operator when applied to two xs:dateTime values. Also used in the definition of the "ne", "le" and "ge" operators.

Signature
 op:dateTime-equal( $arg1 as xs:dateTime, $arg2 as xs:dateTime ) as xs:boolean
Properties

This function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on implicit timezone.

Rules

If either $arg1 or $arg2 has no timezone component, the effective value of the argument is obtained by substituting the implicit timezone from the dynamic evaluation context.

The function then returns true if and only if the effective value of $arg1 is equal to the effective value of $arg2 according to the algorithm defined in section 3.2.7.4 of [XML Schema Part 2: Datatypes Second Edition] "Order relation on dateTime" for xs:dateTime values with timezones. Otherwise the function returns false.

Examples

Assume that the dynamic context provides an implicit timezone value of -05:00

The expression op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00-01:00"), xs:dateTime("2002-04-02T17:00:00+04:00")) returns true().

The expression op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00"), xs:dateTime("2002-04-02T23:00:00+06:00")) returns true().

The expression op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00"), xs:dateTime("2002-04-02T17:00:00")) returns false().

The expression op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00"), xs:dateTime("2002-04-02T12:00:00")) returns true().

The expression op:dateTime-equal(xs:dateTime("2002-04-02T23:00:00-04:00"), xs:dateTime("2002-04-03T02:00:00-01:00")) returns true().

The expression op:dateTime-equal(xs:dateTime("1999-12-31T24:00:00"), xs:dateTime("2000-01-01T00:00:00")) returns true().

The expression op:dateTime-equal(xs:dateTime("2005-04-04T24:00:00"), xs:dateTime("2005-04-04T00:00:00")) returns false().

#### 9.4.2 op:dateTime-less-than

Summary

Returns true if the first argument represents an earlier instant in time than the second argument.

Operator Mapping

Defines the semantics of the "lt" operator when applied to two xs:dateTime values. Also used in the definition of the "ge" operator.

Signature
 op:dateTime-less-than( $arg1 as xs:dateTime, $arg2 as xs:dateTime ) as xs:boolean
Properties

This function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on implicit timezone.

Rules

If either $arg1 or $arg2 has no timezone component, the effective value of the argument is obtained by substituting the implicit timezone from the dynamic evaluation context.

The function then returns true if and only if the effective value of $arg1 is less than the effective value of $arg2 according to the algorithm defined in section 3.2.7.4 of [XML Schema Part 2: Datatypes Second Edition] "Order relation on dateTime" for xs:dateTime values with timezones. Otherwise the function returns false.

#### 9.4.3 op:date-equal

Summary

Returns true if and only if the starting instants of the two supplied xs:date values are the same.

Operator Mapping

Defines the semantics of the "eq" operator when applied to two xs:date values. Also used in the definition of the "ne", "le" and "ge" operators.

Signature
 op:date-equal( $arg1 as xs:date, $arg2 as xs:date ) as xs:boolean
Properties

This function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on implicit timezone.

Rules

The starting instant of an xs:date is the xs:dateTime at time 00:00:00 on that date.

The function returns the result of the expression:

op:dateTime-equal(xs:dateTime($arg1), xs:dateTime($arg2))
Examples

The expression op:date-equal(xs:date("2004-12-25Z"), xs:date("2004-12-25+07:00")) returns false(). (The starting instants are xs:dateTime("2004-12-25T00:00:00Z") and xs:dateTime("2004-12-25T00:00:00+07:00"). These are normalized to xs:dateTime("2004-12-25T00:00:00Z") and xs:dateTime("2004-12-24T17:00:00Z"). ).

The expression op:date-equal(xs:date("2004-12-25-12:00"), xs:date("2004-12-26+12:00")) returns true().

#### 9.4.4 op:date-less-than

Summary

Returns true if and only if the starting instant of $arg1 is less than the starting instant of $arg2. Returns false otherwise.

Operator Mapping

Defines the semantics of the "lt" operator when applied to two xs:date values. Also used in the definition of the "ge" operator.

Signature
 op:date-less-than( $arg1 as xs:date, $arg2 as xs:date ) as xs:boolean
Rules

The starting instant of an xs:date is the xs:dateTime at time 00:00:00 on that date.

The function returns the result of the expression:

op:dateTime-less-than(xs:dateTime($arg1), xs:dateTime($arg2))
Examples

The expression op:date-less-than(xs:date("2004-12-25Z"), xs:date("2004-12-25-05:00")) returns true().

The expression op:date-less-than(xs:date("2004-12-25-12:00"), xs:date("2004-12-26+12:00")) returns false().

#### 9.4.5 op:time-equal

Summary

Returns true if the two xs:time values represent the same instant in time, when treated as being times on the same date, before adjusting the timezone.

Operator Mapping

Defines the semantics of the "eq" operator when applied to two xs:time values. Also used in the definition of the "ne", "le" and "ge" operators.

Signature
 op:time-equal( $arg1 as xs:time, $arg2 as xs:time ) as xs:boolean
Properties

This function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on implicit timezone.

Rules

Each of the supplied xs:time values is expanded to an xs:dateTime value by associating the time with an arbitrary date. The function returns the result of comparing these two xs:dateTime values using op:dateTime-equal.

The result of the function is thus the same as the value of the expression:

op:dateTime-equal(
fn:dateTime(xs:date('1972-12-31'), $arg1), fn:dateTime(xs:date('1972-12-31'),$arg2))
Examples

Assume that the date components from the reference xs:dateTime correspond to 1972-12-31.

The expression op:time-equal(xs:time("08:00:00+09:00"), xs:time("17:00:00-06:00")) returns false(). (The xs:dateTimes calculated using the reference date components are 1972-12-31T08:00:00+09:00 and 1972-12-31T17:00:00-06:00. These normalize to 1972-12-30T23:00:00Z and 1972-12-31T23:00:00Z. ).

The expression op:time-equal(xs:time("21:30:00+10:30"), xs:time("06:00:00-05:00")) returns true().

The expression op:time-equal(xs:time("24:00:00+01:00"), xs:time("00:00:00+01:00")) returns true(). (This not the result one might expect. For xs:dateTime values, a time of 24:00:00 is equivalent to 00:00:00 on the following day. For xs:time, the normalization from 24:00:00 to 00:00:00 happens before the xs:time is converted into an xs:dateTime for the purpose of the equality comparison. For xs:time, any operation on 24:00:00 produces the same result as the same operation on 00:00:00 because these are two different lexical representations of the same value. ).

#### 9.4.6 op:time-less-than

Summary

Returns true if the first xs:time value represents an earlier instant in time than the second, when both are treated as being times on the same date, before adjusting the timezone.

Operator Mapping

Defines the semantics of the "lt" operator when applied to two xs:time values. Also used in the definition of the "ge" operator.

Signature
 op:time-less-than( $arg1 as xs:time, $arg2 as xs:time ) as xs:boolean
Properties

This function is ·deterministic·, ·context-dependent·, and ·focus-independent·. It depends on implicit timezone.

Rules

Each of the supplied xs:time values is expanded to an xs:dateTime value by associating the time with an arbitrary date. The function returns the result of comparing these two xs:dateTime values using op:dateTime-less-than.

The result of the function is thus the same as the value of the expression:

op:dateTime-less-than(
fn:dateTime(xs:date('1972-12-31'), $arg1), fn:dateTime(xs:date('1972-12-31'),$arg2))
Examples

Assume that the dynamic context provides an implicit timezone value of -05:00.

The expression op:time-less-than(xs:time("12:00:00"), xs:time("23:00:00+06:00")) returns false().

The expression op:time-less-than(xs:time("11:00:00"), xs:time("17:00:00Z")) returns true().

The expression op:time-less-than(xs:time("23:59:59"), xs:time("24:00:00")) returns false().

#### 9.4.7 op:gYearMonth-equal

Summary

Returns true if the two xs:gYearMonth` values have the same starting instant.