Convert from Base 10

Converts an integer to a corresponding sequence of words

This example demonstrates a function that converts any non-negative integer into a sequence of English words for each of its digits, such as turning `0` into "zero". The code defines two recursive and iterative XQuery functions: `local:number-to-seq` first splits the integer into individual digits using integer division and modulo operations, then `local:int-to-string` maps each digit to its corresponding word via a `switch` expression. The final call, `local:int-to-string(0)`, executes the conversion and returns the word sequence. It relies solely on standard XQuery 3.0 functions like `fn:floor` and `fn:mod`, with no external libraries.

68% match

Playing with Higher Order Functions in XQuery

This example demonstrates how higher-order functions in XQuery 3.1 enable function composition for transforming numeric sequences. It shows a square function (`$map-sqr`) that uses the simple map operator (`!`) with `math:pow`, which is then fed into a reversal function (`$pow-rev`) via the `=>` arrow operator. The code applies `fn:reverse` to the input sequence before passing it to the squared map, returning the squares of the reversed order. The rendered output is computed in-memory with no external data source, purely exercising the language’s functional capabilities.

58% match

Fibonacci sequence in XQuery

This example visualizes the Fibonacci sequence by generating and plotting the first fifteen numbers through XQuery code. The visualization shows the numeric progression of the sequence, with each value computed recursively via the `local:fibo-numbers` function, which takes two starting integers and a limit. The rendering approach is plain text or tabular output, as the code only returns the sequence values without graphical mapping. It uses standard XQuery 3.0 functions and user-defined functions, with no external libraries or APIs, focusing purely on functional sequence generation. The data source is the code’s own hardcoded initial parameters, 0 and 1, and the result is a simple list of integers.

57% match

XQuery Fibonacci

This example computes the 30th Fibonacci number using a recursive XQuery function defined in a separate module. It demonstrates XQuery 3.1’s switch expression and integer arithmetic through the `local:fib` function, which calls itself until it reaches the base cases of 0 and 1. The final result is returned directly without any visualization, showing a pure server-side computation. The source code is stored as a gist by CliffordAnderson.

57% match

The Euclidean Algorithm in XQuery

This example demonstrates two implementations of the Euclidean algorithm in XQuery, computing the greatest common divisor of 13 and 8. The first function, `local:euclid`, uses repeated subtraction, while the second, `local:gcd`, employs the more efficient division-and-remainder method. Both functions return the result as an `xs:integer*` sequence using XQuery’s built-in arithmetic and type declarations. The code is drawn from a gist by CliffordAnderson and serves as a minimal, functional illustration of algorithmic logic in a query language.

Factorial

This example demonstrates the computation of the factorial of 10 using XQuery 3.1. It shows two distinct implementation approaches: a recursive function `local:fac` and a higher-order function `local:hFac` that uses `fn:fold-right` with an anonymous function. The program executes `local:hFac(10)`, which iteratively multiplies values from 1 to 10. The data is not visualized graphically; instead, the output is the numeric result of the calculation. The code relies on XQuery’s built-in type annotations (`xs:int`) and function library, with no external visualization libraries involved.

Binary and Hex Conversion in Julia

This example defines two recursive Julia functions, `tobin` and `tohex`, that manually convert a decimal integer into its binary and hexadecimal string representations. The code demonstrates pattern matching with the `Match` package: `tobin` handles base 2, while `tohex` maps digits 0–9 and letters A–F for base 16, using the `div` and `mod` functions to decompose the input. The functions are intended to be compared against Julia’s built-in `bits()` and `hex()` utilities, though no visualization or data source is included.

Example of a FLWOR expression

This example demonstrates a FLWOR expression in XQuery, showing how to compute the squares of odd numbers from 1 to 10 and return them in descending order. The data source is an inline numeric range, and the result sequence is produced by iterating with a `for` clause, binding each square with `let`, filtering odd values using a `where` condition, and sorting with `order by` before the final `return`. The code relies on the standard XQuery 3.0 library and its built-in arithmetic operators, with no external APIs or rendering components involved.