# REXX

Version of implementation IBM "Classic" REXX of programming language REXX

The examples should work in all versions of REXX.

## Examples:

### Hello, World! - REXX (97):

``````say 'Hello, World!'
``````

### Factorial - REXX (98):

This example uses recursive factorial definition.

Line 3: REXX allows the numeric precision to be set arbitrarily large — as much as your memory will allow.

Line 6: String concatenation works by juxtaposing values and literals, with or without intervening spaces. If two values must be concatenated, the || operator can be used.

Line 10: The optional PROCEDURE keyword causes the routine’s variables to be local; without it they are global to the program.

The output looks as follows:

0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
9! = 362880
10! = 3628800
11! = 39916800
12! = 479001600
13! = 6227020800
14! = 87178291200
15! = 1307674368000
16! = 20922789888000
17! = 355687428096000
18! = 6402373705728000
19! = 121645100408832000
20! = 2432902008176640000
21! = 51090942171709440000
22! = 1124000727777607680000
23! = 25852016738884976640000
24! = 620448401733239439360000
25! = 15511210043330985984000000
26! = 403291461126605635584000000
27! = 10888869450418352160768000000
28! = 304888344611713860501504000000
29! = 8841761993739701954543616000000
30! = 265252859812191058636308480000000

``````  1  #!/usr/bin/rexx
2  /* Compute n! */
3    numeric digits 40
4
5    do n = 0 to 30
6      say right(n,2)"! = " right(factorial(n),35)
7    end
8  exit
9
10  factorial: procedure
11    parse arg n .
12
13    if n = 0 then
14      n = 1
15
16    else
17      n = n * factorial(n - 1)
18  return n
``````

### Fibonacci numbers - REXX (99):

This example uses recursive definition of Fibonacci numbers.

`````` 1  #!/usr/bin/rexx
2  /* Calculate Fibonacci using recursion */
3
4    numbers = ''
5
6    do n = 1 to 16
7      numbers = numbers fibonacci(n)","
8    end
9
10    say numbers"..."
11  exit
12
13  fibonacci: procedure
14    parse arg n .
15
16    if n < 3 then
17      n = 1
18
19    else
20      n = fibonacci(n-1) + fibonacci(n-2)
21  return n
``````

### Fibonacci numbers - REXX (100):

This example uses iterative definition of Fibonacci numbers.

In REXX, an uninitialized variable has its name in uppercase as its value; e.g. numbers = ‘NUMBERS’

Line 4: Arrays are called “stem variables”. The root of a stem ends with a period. Elements of a stem are named by adding a value to the stem; e.g. fib.1, fib.first, etc. Additional dimensions may be used by adding another period and value; e.g., fib.1.3; To initialize all possible stem instances, assign a value to the stem name; e.g., fib. = 0 or fib. = ”

`````` 1  #!/usr/bin/rexx
2  /* Calculate Fibonacci using an associative array */
3
4    fib.  = ''
5    fib.1 = 1
6    fib.2 = 1
7    numbers = ''
8
9    do f = 3 to 16
10      e = f - 1; d = f - 2
11      fib.f = fib.e + fib.d
12    end
13
14    do n = 1 to 16
15      numbers = numbers fib.n','
16      fib.f = fib.e + fib.d
17    end
18
19    say numbers"..."
20  exit
``````