Collections: Difference between revisions

There are several methods to store collections in REXX:

::::*   stemmed arrays   (or simply, arrays)

::::*   lists   or   vectors

::::*   sparse stemmed arrays;   (or simply, sparse arrays)

A collection can be numbers   (integer or floating point numbers),   or any

character strings   (including ''nulls'').

Indeed, even numbers in REXX are stored as characters.

To store (say) a collection of numbers   (or anything,

for that matter)   into a stemmed array:

<lang rexx>pr. = /*define a default for all elements for the array*/

pr.1 = 2 /*note that this array starts at 1 (one). */

pr.2 = 3

pr.3 = 5

pr.4 = 7

pr.5 = 11

pr.6 = 13

pr.7 = 17

pr.8 = 19

pr.9 = 23

pr.10 = 29

pr.11 = 31

pr.12 = 37

pr.13 = 41

pr.14 = 43

pr.15 = 47

y. = 0 /*define a default for all years (Y) to be zero*/

y.1985 = 6020

x = y.2012 /*the variable X will have a value of zero (0).*/

fib.0 = 0 /*this stemmed arrays will start with zero (0). */

fib.1 = 1

fib.2 = 1

fib.3 = 2

fib.4 = 3

fib.5 = 5

fib.6 = 8

fib.7 = 17

do n=-5 to 5 /*define a stemmed array from -5 to 5 */

sawtooth.n = n /*the sawtooth array is, well, a sawtooth curve*/

end /*n*/ /*note that eleven elements will be defined. */</lang>

Most often, programmers will assign the &nbsp; zero &nbsp; entry to the

number of elements in the stemmed array.

This means that any index of the stemmed array must be positive to be useful for

storing numbers.

<lang rexx> pr.0= 15 /*number of (data) entries in the stemmed array. */</lang>

Programmatically, a simple test could be performed to detect the

end of the array &nbsp; (if there aren't any &nbsp; ''null'' &nbsp; values):

<lang rexx> do j=1 while pr.j\==''

say 'prime' j "is" pr.j

/*at this point, J=16 (because of the DO */

/*loop incrementing the index. */

j= j-1 /*J now has the count of primes stored. */</lang>

To store (say) a collection of numbers (or anything, for that matter) into a list:

<lang rexx>primeList = '2 3 5 7 11 13 17 19 23 29 31 37 41 43' /* or ··· */

primeList = 2 3 5 7 11 13 17 19 23 29 31 37 41 43

/*in this case, the quotes (') can be elided.*/

primes= words(primeList) /*the WORDS BIF counts the number of blank─ */

/*separated words (in this case, prime numbers)*/

/*in the value of the variable "primeList".*/

do j=1 for primes /*can also be coded as: do j=1 to primes */

say 'prime' j "is" word(primeList, j)

/*this method (using the WORD BIF) isn't */

/*very efficient for very large arrays (those */

/*with many many thousands of elements). */

The use of lists (in the above manner) is suitable for words (or numbers) that do not have

leading, embedded, or

<br>trailing blanks as part of their value.

One workaround is to use some other unique character &nbsp; (such as an

underbar/underscore &nbsp; <big>'''_'''</big> &nbsp; character) &nbsp; that

<br>that can be substituted, and then later, be translated to a true blank.

To store (for instance) a collection of numbers (or anything, for that matter) into

a sparse stemmed array:

<lang rexx>pr. = 0 /*define a default for all elements for the array.*/

pr.2 = 1

pr.3 = 1

pr.5 = 1

pr.7 = 1

pr.11 = 1

pr.13 = 1

pr.17 = 1

pr.19 = 1

pr.23 = 1

pr.29 = 1

pr.31 = 1

pr.37 = 1

pr.41 = 1

pr.43 = 1

pr.47 = 1

/*──────────────────────────────────────────────────────────────────────────────────────*/

do j=1 for 10000 /*this method isn't very efficient. */

if \pr.j then iterate /*Not prime? Then skip this element. */

primes = primes + 1 /*bump the number of primes (counter).*/

end /*j*/

/*note that the 10000 is a small "∞".*/

say '# of primes in list:' primes

/*──────────────────────────────────────────────────────────────────────────────────────*/

do j=1 for 10000 /*this method is not very efficient. */

if pr.j\==0 then #primes = #primes + 1 /*Not zero? Bump the number of primes.*/

end /*j*/ /* [↑] not as idiomatic as 1st program*/

say '# of primes in the list:' #primes

/*──────────────────────────────────────────────────────────────────────────────────────*/

Ps=0

do k=1 for 10000 /*and yet another inefficient method. */

if pr.k==0 then iterate /*Not a prime? Then skip this element.*/

Ps = Ps + 1 /*bump the counter for the # of primes.*/

say 'prime' Ps "is:" k /*might as well echo this prime number.*/

end /*k*/

say 'The number of primes found in the list is ' Ps

/*──────────────────────────────────────────────────────────────────────────────────────*/

highPrime= 47 /*hardcode the highest prime in array. */

Ps = 0

do k=1 for highPrime /*and much more efficient method. */

if \pr.k then iterate /*Not a prime? Then skip this element.*/

Ps = Ps + 1 /*bump the counter for the # of primes.*/

say 'prime' Ps "is:" k /*might as well echo this prime number.*/

end /*k*/

say 'The number of primes found in the list is: ' Ps</lang>

The above &nbsp; '''do''' &nbsp; loop could've been coded as:

<lang rexx>

do k=1 to highPrime /*and much more efficient method. */</lang>

but a &nbsp; '''for''' &nbsp; clause is faster than a &nbsp; '''to''' &nbsp; clause.

<br><br>