POWERING GREATER CREATORS Creative people everywhere choose Avid to make today’s most celebrated video and audio content—from iconic movies, binge-worthy TV series, and engaging news and sports shows to chart-topping music and live performances. Meet Pro Tools Carbon Pre Our most transparent preamp design ever. Find out what it brings to your studio. Give Edit On Demand a Spin Fast, secure, cloud-based video editing and storage with easy setup and no hidden fees.

What’s New, VENUE? Unlock Waves V14 integration, new ways to side chain, and BIG FrEQ by Empirical Labs. Back for Season Three In the season premiere, Avid CEO Jeff Rosica discusses the future of the media business. The key to writing beautiful music—raise your bar with Sibelius. See how. THE TOOLS THAT POWER AN INDUSTRY Create. Buy now. Contact us.

LEAR N. DISCOVE R. GET INSPIRE D. Find, connect, and collaborate with other creatives around the world. Get help. The auxiliary verb must , when rendered in small capitals, indicates a precondition for conformance.

When the sentence relates to an implementation of a function for example "All implementations must recognize URIs of the form 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. 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.

This section is concerned with the question of whether two calls on a function, with the same arguments, may produce different results. 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:.

Two items are identical if and only if one of the following conditions applies:. 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.

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 ·. Both items are arrays, both arrays have the same number of members, and the members are pairwise · identical ·. Both items are function items, neither item is a map or array , and all the following conditions apply:.

Either both functions have the same name, or both names are absent DM 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.

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. Both functions have the same nonlocal variable bindings sometimes called the function's closure. 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.

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. 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.

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 ·. 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 focus XP These functions will in general return different results on different calls if the focus is different.

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.

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.

All functions defined in this specification are · deterministic · unless otherwise stated. Exceptions include the following:. In such cases two calls with the same arguments are not guaranteed to produce the results in the same order. These functions are said to be nondeterministic with respect to ordering. Some functions such as fn:analyze-string , fn:parse-xml , fn:parse-xml-fragment , and fn:json-to-xml construct a tree of nodes to represent their results.

There is no guarantee that repeated calls with the same arguments will return the same identical node in the sense of the is operator. However, if non-identical nodes are returned, their content will be the same in the sense of the fn:deep-equal function.

Such a function is said to be non-deterministic with respect to node identity. Some functions such as fn:doc and fn:collection create new nodes by reading external documents. Such functions are guaranteed to be · deterministic · with the exception that an implementation is allowed to make them non-deterministic as a user option.

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. Accessors and their semantics are described in [XQuery and XPath Data Model XDM 3. 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. 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 ·.

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. Otherwise, the function returns the result of the dm:node-name accessor as defined in [XQuery and XPath Data Model XDM 3. If the context item is absent DM31 , dynamic error [ err:XPDY ] XP If the context item is not a node, type error [ err:XPTY ] XP 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 absent DM 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 absent DM31 and the local part is the namespace prefix being bound.

Otherwise the function returns the result of the dm:nilled accessor as defined in [XQuery and XPath Data Model XDM 3. That is, calling fn:string is equivalent to calling fn:string. A dynamic error is raised [ err:XPDY ] XP31 by the zero-argument version of the function if the context item is absent DM 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.

Returns the result of atomizing a sequence. This process flattens arrays, and replaces nodes by their typed values. 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.

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. 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 zero-argument version of the function returns the base URI of the context node: it is equivalent to calling fn:base-uri. 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.

In this document, as well as in [XQuery 3. 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. 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. The fn:error function is a general function that may be called as above but may also be called from [XQuery 3. This function is · nondeterministic · , · context-independent · , and · focus-independent ·.

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 way in which error information is returned to the external processing environment is · implementation-dependent ·.

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.

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. This function always raises a dynamic error. By default, it raises [ err:FOER ]. The type "none" is a special type defined in [XQuery 1. 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. The expression fn:error raises error FOER This function is · deterministic · , · context-independent · , and · focus-independent ·.

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 ·. Sometimes there is a need to output trace information unrelated to a specific value.

Consider a situation in which a user wants to investigate the actual value passed to a function. This section specifies arithmetic operators on the numeric datatypes defined in [XML Schema Part 2: Datatypes Second Edition]. 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.

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 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. This specification uses [IEEE ] 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 ].

A conformant implementation must respect these semantics. In consequence, the expression As a concession to implementations that rely on implementations of XSD 1. XML Schema 1. The following functions define the semantics of arithmetic operators defined in [XQuery 3. 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. The result type of operations depends on their argument datatypes and is defined in the following table:. These rules define any operation on any pair of arithmetic types.

Consider the following example:. 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 They may then derive fenceHeight using an enumeration to restrict the permitted set of values to, say, 36, 48 and 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 ]. 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 ]. This specification allows the following options:. Raising a dynamic error [ err:FOAR ] via an overflow trap.

For xs:float and xs:double operations, underflow behavior must be conformant with [IEEE ]. Raising a dynamic error [ err:FOAR ] via an underflow trap. Returning 0. For xs:decimal operations, overflow behavior must raise a dynamic error [ err:FOAR ]. On underflow, 0. 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:FOAR ]. 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 ]. 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. 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. 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 1e to 1e requires digits of precision for an accurate representation of the result. The [IEEE ] 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 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 [IEEE ] 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.

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. Defines the semantics of the "-" operator when applied to two numeric values. 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. 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. Defines the semantics of the "div" operator when applied to two numeric values. A dynamic error is raised [ err:FOAR ] for xs:decimal and xs:integer operands, if the divisor is positive or negative zero. For xs:float and xs:double operands, floating point division is performed as specified in [IEEE ]. 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. Defines the semantics of the "idiv" operator when applied to two numeric values.

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.

A dynamic error is raised [ err:FOAR ] if the divisor is positive or negative zero. Defines the semantics of the "mod" operator when applied to two numeric values. 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 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. Division is truncating division, analogous to integer division, not [IEEE ] rounding division i. additional digits are truncated, not rounded to the required precision.

Defines the semantics of the unary "-" operator when applied to a numeric value. For xs:integer and xs:decimal arguments, 0 and 0. For xs:float and xs:double arguments, NaN returns NaN , 0. INF returns -INF. This specification defines the following comparison operators on numeric values. Comparisons take two arguments of the same type.

If the arguments are of different types, one argument is promoted to the type of the other as described above in 4. Each comparison operator returns a boolean value. If either, or both, operands are NaN , false is returned. 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".

General rules: see 4. For xs:float and xs:double values, positive zero and negative zero compare equal. INF equals INF , and -INF equals -INF. NaN does not equal itself. Defines the semantics of the "lt" operator when applied to two numeric values, and is also used in defining the semantics of "le". 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.

Defines the semantics of the "gt" operator when applied to two numeric values, and is also used in defining the semantics of "ge". The following functions are defined on numeric types. Each function returns a value of the same type as the type of its argument. 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. 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. The result may also be an instance of a type derived from one of these four by restriction. 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. 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. Rounds a value to a specified number of decimal places, rounding upwards if two such values are equally near.

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. For arguments of type xs:float and xs:double the results may be counter-intuitive.

For example, consider round The result is not This is because the xs:double written as The expression fn:round Not the possible alternative, Rounds a value to a specified number of decimal places, rounding to make the last digit even if two such values are equally near.

If two such values are equally near e. If the argument is NaN , positive or negative zero, or positive or negative infinity, then the result is the same as the argument. 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.

If the resulting xs:decimal value is zero, then positive or negative zero is returned according to the sign of the original argument. This function is typically used in financial applications where the argument is of type xs:decimal.

For example, consider round-half-to-even xs:float This is because the conversion of the xs:float value represented by the literal The expression fn:round-half-to-even 3. 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. 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. If the conversion to xs:double fails, the xs:double value NaN is returned. 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. XSD 1. It is · implementation-defined · whether XSD 1. 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. Assume that the context item is the xs:string value " 15 ". Then fn:number returns 1. Formats an integer according to a given picture string, using the conventions of a given natural language if specified.

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 ·. The rules that follow describe how non-negative numbers are output. 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. A decimal-digit-pattern made up of optional-digit-signs , mandatory-digit-signs , and grouping-separator-signs.

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 , , or 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 it contains a digit but does not match this pattern, a dynamic error is raised [ err:FODF ].

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 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.

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.

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.

The grouping separator template is a possibly infinite set of position, character pairs. 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.

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. If there are no grouping separators, then the grouping separator template is an empty set.

Let S 1 be the result of formatting the supplied number in decimal notation as if by casting it to xs:string. Let S 2 be the result of padding S 1 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. Let S 3 be the result of replacing all decimal digits in S 2 with the corresponding digits from the selected digit family. Let S 4 be the result of inserting grouping separators into S 3 : for every position P , character C pair in the grouping separator template where P is less than the number of digits in S 3 , insert character C into S 3 at position P , counting from the right-hand end.

Let S 5 be the result of converting S 4 into ordinal form, if an ordinal modifier is present, as described below. The format token A , which generates the sequence A B C Z AA AB AC The format token a , which generates the sequence a b c z aa ab ac The format token i , which generates the sequence i ii iii iv v vi vii viii ix x The format token I , which generates the sequence I II III IV V VI VII VIII IX X The format token w , which generates numbers written as lower-case words, for example in English, one two three four The format token W , which generates numbers written as upper-case words, for example in English, ONE TWO THREE FOUR The format token Ww , which generates numbers written as title-case words, for example in English, One Two Three Four 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. 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 x, ʹ and sometimes an aristeri keraia x, ͵ 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 the numbering sequences described above any upper bound imposed by the implementation must not be less than 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 x Cyrillic capital letter A.

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. Note that this permits the identification of sublanguages based on country codes from ISO as well as identification of dialects and regions within a country.

The set of languages for which numbering is supported is · implementation-defined ·. 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 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. 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 ·. A dynamic error is raised [ err:FODF ] 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.

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. 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' then the number one million will be formatted as 1'' , while the number fifteen will be formatted as 0' 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'' , while the number fifteen will be formatted as 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.

Grouping separators are not designed for effects such as formatting a US telephone number as 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.

Numbers will never be truncated. Given the decimal-digit-pattern 01 , the number three hundred will be output as , despite the absence of any optional-digit-sign. 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.

format-integer , 'w' might return "one hundred and twenty-three". format-integer 14, 'Ww;o -e ', 'de' might return "Vierzehnte". This function can be used to format any numeric quantity, including an integer.

For integers, however, the fn:format-integer function offers additional possibilities. 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:. A phrase such as "The minus-sign XP31 character" is to be read as "the character assigned to the minus-sign XP31 property in the relevant decimal format within the static context".

For any named or unnamed decimal format, the properties representing characters used in a · picture string · must have distinct values. These properties are decimal-separator XP31 , grouping-separator XP31 , exponent-separator XP31 , percent XP31 , per-mille XP31 , digit XP31 , and pattern-separator XP Furthermore, none of these properties may be equal to any · character · in the · decimal digit family ·.

Returns a string containing a number formatted according to a given picture string, taking account of decimal formats specified in the static context. 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. 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 syntax of the picture string is described in 4. 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.

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 evaluation of the fn:format-number function takes place in two phases, an analysis phase described in 4.

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. 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. 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. The following examples assume a default decimal format in which the chosen digits are the ASCII digits , the decimal separator is ".

The expression format-number The following example assumes the existence of a decimal format named 'ch' in which the grouping separator is ʹ and the decimal separator is · :. The following examples assume that the exponent separator is in decimal format 'fortran' is 'E':. The expression format-number 0. This differs from the format-number function previously defined in XSLT 2. 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 '' with format-dateTime which used ''. The picture string is a sequence of · characters · , in which the characters assigned to the properties decimal-separator XP31 , exponent-separator XP31 , grouping-separator XP31 , and digit XP31 , and pattern-separator XP31 and the members of the · decimal digit family · , are classified as active characters, and all other characters including the values of the properties percent XP31 and per-mille XP31 are classified as passive characters.

A dynamic error is raised [ err:FODF ] 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-separator XP31 character.

A picture-string must not contain more than one instance of the pattern-separator XP31 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-separator XP31 character. A sub-picture must not contain more than one instance of the percent XP31 or per-mille XP31 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 ·.

Lowest price ever See all deals. See all deals. Creative people everywhere choose Avid to make today’s most celebrated video and audio content—from iconic movies, binge-worthy TV series, and engaging news and sports shows to chart-topping music and live performances.

Achieve your best work with tools, solutions, and services that bring your creative inspiration to life. Industry-standard software for musicians, mixers, producers, and engineers. Powerful video editing software for projects of any size, from first cut to final finishing.

Easy-to-use notation software to compose, arrange, and engrave for any ensemble. Workflow-optimized tiered storage for real-time media production. End-to-end media workflow management to streamline your entire operation. Fully configured post-production environment in the cloud for editing from anywhere. End of Year Savings Lowest price ever See all deals. POWERING GREATER CREATORS Creative people everywhere choose Avid to make today’s most celebrated video and audio content—from iconic movies, binge-worthy TV series, and engaging news and sports shows to chart-topping music and live performances.

Meet Pro Tools Carbon Pre Our most transparent preamp design ever. Find out what it brings to your studio. Give Edit On Demand a Spin Fast, secure, cloud-based video editing and storage with easy setup and no hidden fees. What’s New, VENUE?

Unlock Waves V14 integration, new ways to side chain, and BIG FrEQ by Empirical Labs. Back for Season Three In the season premiere, Avid CEO Jeff Rosica discusses the future of the media business. The key to writing beautiful music—raise your bar with Sibelius.

See how. THE TOOLS THAT POWER AN INDUSTRY Create. Buy now. Contact us. LEAR N. DISCOVE R. GET INSPIRE D.

Find, connect, and collaborate with other creatives around the world. Get help. Learn something new. Ask and answer questions. And so much more. Discover the Avid Community Find, connect, message, and collaborate with other creators Dive in. Artist Relations Powering greater creators like you Visit Iamavid. Remote Media Production Discover the easiest way to move production to the cloud See how. Online Learning Get inspired with free sessions for music, video, and graphics View webinars.

The expression math:atan xs:double 'INF' returns 1. I'll start with the simple concepts and introduce the advanced topics later on. In this next section I will describe three commands, one of which cannot operate on a range. The expression format-number Namespaces Article Talk. 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. Specifying which occurrence With no flags, the first matched substitution is changed.

Categories:

• Binary Options online
• Forex
• Forex Bitcoin
• Forex Brokers
• Binary Options