Simple Numeric Indexing Comments

General:This frame introduces you to simple indexing principals in Glee.A general rule to remember regarding indexing: If the element does not exist, Glee. returns nil.

Simple Indexing: From the vector (10 20 30) the elements (4 3 2 1 0) are extracted in that order yielding (Nil 30 20 10 Nil). The 4th element and the 0th element don't exist so Nil results.

Insert Indexing: When you index with a fractional index, this tells Glee you want to insert elements into the result. The integer indices you already understand from the previous example. But decimal indices tell Glee to open a space for the value and use the value from the integer part of the index. In this example, 1.1 leaves a space in the result and fills it with the value at vector position 1. Notice there is nothing at vector position 0 or 4 or 4.1 so those indices yield Nil.

Here I also illustrate saving a value into a variable (10 20 30=>n). "=>" is the assignment operator in Glee. It is formed by the equal symbol ("=") followed with no intervening white space by the greater than (">") symbol (it does not mean "equal to or greater than"). The value to the left of the operator is saved in the namespace under the name to the right in the spirit of Glee's left to right operation. This is alien to virtually everyone, but is consistent to Glee's left to right parsing. I will use variables in this tutorial to break examples into steps.

I can then reference the variable (in this case "n") in the indexing operation as n[0 0.1 1 1.1 2 2.1 3 3.1 4 4.1] yielding Nil Nil 10 10 20 20 30 30 Nil Nil

Index Generation Operator:The "left single quote" ("`" is on the key with the "~" symbol and to the left of the "1 and ! " key on my keyboards) tells Glee to create an index vector. This is a numeric integer vector with the numbers 1 to n where n is the value preceeding the symbol. In this example "3`" produces the index vector 1 2 3. The "`" operator is called the index generator.

Indexing with index generator: This example creates the numbers from 1 to 7 ("7`"). It then takes that result and indexes it with the result of ("4`+2") which yields 3 4 5 6 as the index. Indexing into 1 2 3 4 5 6 7 with 3 4 5 6 yields 3 4 5 6.
Note: The parenthesis in the expression "(7`)" are not required. Working left to right there is no ambiguity related to what I have on the left. I include the parenthesis for readability here. It makes your eyes see 7` as an object being indexed.

Indexing with the range operator: The range operator ("..") is formed by two consecutive periods (".."). It is a more direct way to generate arbitrary index ranges.

The "$" in this example tells Glee to display intermediate results. In this case it displays (1 2 3 4 5 6 7). This is followed by the semicolon (";") which is Glee's instruction separator. If Glee finishes without seeing a semicolon, it displays the result of its last operation. However, if it does see a semicolon, it displays nothing. Using the "$" as a debugging aid allows us to see the contents of "n" for this example before we index into it.

Indexed Assignment: You can use indexed assignment to change the contents of variables. This example shows three statements.
Statement 1: (7` => n;) creates a variable n containing the integers 1 thru 7
Statement 2:( 44 33 99=>[4 3 9 2]n;) works like this. First, it does an implicit left take 4 (the length of the index vector 4 3 9 2) on the value vector (44 33 99). This yields 44 33 99 99 which it assigns to elements 4 3 9 2 of the object n. Since there is no element 9, the value at that respective position (33) is discarded. The result is 1 99 44 33 5 6 7. I expect you'll find the syntax a little unpleasant at first and favor ( 44 33 99=>n[4 3 9 2];). There's a problem with that. Left to right parsing would reassign the three element vector 44 33 99 to n. It would then index 44 33 99 at elements 4 3 9 2 giving Nil 99 Nil 33. This having no place to go as the result, would display. The contents of n get clobbered in the process. The syntax was a little funny to me at first too but I have no trouble with it now.
Statement 3: Giving a variable name as a lone statement not followed by a semicolon displays the contents of the variable. In this case we display the contents of the variable "n".

The indexed assignment proceeds from left to right through the indices and associated values. Thus, if an index value appears more than once, it is the last assignment that takes effect.

This example demonstrates an important characteristic of Glee. It trys to do the best it can with the materials it is given. The rules it uses are defined and logical. Most other programming languages would squawk at you and quit when things don't match up. I think they're being too finicky for human use, but of course with their style, they have to be.

Sneak preview of right and left take: In the previous example I said Glee does an implicit left take 4. Here we do an explicit right take 4 using the "->" right take operator in the statement ( 44 33 99 -> 4 ) yielding 44 44 33 99. Just for orientation, a left take would be (44 33 99 <- 4 ) and yields 44 33 99 99.

Boolean indexing (or selection):Here I begin to give you a taste of innate power of Glee. In one simple statement I mark all elements of n which are greater than or equal to ("*>=") 2 and less than ("*<") 6, and you knew what it did before I told you. But you probably didn't know the mechanism Glee used. It is called selection and it has to do with boolean objects (vectors of values of 1 and 0 or true and false called bits). In the space taken to store a single floating point number (like 1.1), Glee can store 64 bits of boolean (sometimes called logical) data. Within the index of operator ("[  ]") I perform three logical operations. I test for >=2; I test for < 6; and I logical and bit by bit("&") the results of the two tests. This gives me my boolean selection vector ("0111100"). I display this using the "$" debugging display operator. If I use a boolean as an index, I get a value from the indexed object everywhere there is a 1 or true. I don't get a value where there is a 0 or false. As we will see later, this capability is very powerful for performing numeric analysis. It is also powerful in string search and compare operations.
Note: You may be tempted to say equal to or greater than and use the => operator for this logical operation. Don't!!! That is assignment!

Literal Boolean Indexing: Glee has a special facility for entering literal boolean values to be used in indexing. A string containing only 1's and 0's is taken as a bit vector when supplied as in index. Glee selects the element corresponding to each 1 and discards the element corresponding to each 0. When the index implied is outside the range of elements, Nil is returned.

Empty index:
As with all Glee objects, presenting an empty index causes Glee to return a copy of the object's contents. In this case, 1 2 3.