Objects and data types
From NEST
Contents |
Overview
Anything that can be put on the stack is called object. There are several different types of objects, which can store different types of data. For a number of object types there exist two different states: executable and literal. Some object types can change between these two states. Literal objects are the majority and are simply pushed on the stack when they are entered. By contrast, executable objects perform some operation when they are entered and cannot easily be pushed on the stack.
Numbers
SLI distinguishes between real and integer numbers. Real numbers
correspond to the type double in C/C++. Integer numbers
correspond to the type long int of C/C++.
Examples
Real numers are: 1.4, .5, 1., 1e-2
Integer numers are 1, 2, 3000
Arrays
Arrays are sequential containers which can hold any SLI object. The elements of an array are indexed, starting with zero (0) as the first index.
SLI arrays are heterogeneous. Objects of different type may be mixed within one array. Arrays may also be nested to define matrices or tensors of arbitrary rank.
Arrays are delimited by square brackets. The different elements of an array are separated by white-spaces.
Examples
[1 2 3] % a simple array with integers [1 a b] % a mixed array [[1 2 3] [4 5 6]] % a 2x3 Matrix defined by nested array
Calculate the dot product of the vectors ![[1 2 3]\cdot[4 5 6]](/images/math/d/f/6/df6c79f1109920edee88204d653f10bf.png)
SLI ] [1 2 3] SLI [1] [4 5 6] SLI [2] Dot = 32
Names
Names are used to create variables and to identify specific SLI objects. If a name is entered, it is immediately executed.
If you want to put a name on the stack without evaluating it, you
need to protect it by prepending a shash character
(e.g. /a). In this case, the name is called a literal name.
The command def is used to create an associoation between
a name an an object.
Example
SLI ] /pi 3.1415 def SLI ] pi SLI [1] = 3.1415
The command who gives the list of names which have been
defined during the SLI session.
Example
Define the variables a and b with values 1 and 2 and calculate a+b
SLI ] /a 1 def SLI ] /b 2 def SLI ] a b add SLI ] = 3 SLI ] who -------------------------------------------------- Name Type Value -------------------------------------------------- pi doubletype 3.1415 a integertype 1 b integertype 2 -------------------------------------------------- Total number of dictionary entries: 3
Strings
Strings are sequences of characters, delimited by parenthesis. In SLI, characters are represented by interger numbers, e.g. 97 represents the letter 'a', while 32 represents the space character.
The elements of a string are indexed, starting with zero (0) as the first index.
Matched pairs of parentheses may be used inside strings.
Examples
SLI ] (Hello World!) = Hello World!
Procedures
Procedures are a sequence of SLI commands, enclosed by the
delimiters { and }. The delimiters prevent the
objects from being executed as you enter them. Rather, they will
be executed, when you evaluate the procedure.
Bound to a name, procedures can be used like any builtin SLI command.
Example: Hello World
Print the string Hello World!.
/HelloWorld
{
(Hello World !) =
} def
Dictionaries
A dictionary is an associative array. It stores pairs of names and objects, where the name acts as a key to access the object inside the dictionary.
The pairs are delimited by the characters << and >>. Note that the pairs are evaluated during the construction of the dictionary. Thus, literal names have to be used here. The individual name/value pairs have no defined sequential order (unlike a real dictionary where the keys are ordered alphabetically).
Example
Create a dictionary which stores named parameters.
SLI ] /parameters << /alpha 1.0 /beta 3.5 /tau 10.0 >> def SLI ] parameters /tau get = 10
Example: Showing dictionaries
The command info can
be used to examine the contents of a dictionary.
SLI ] parameters info -------------------------------------------------- Name Type Value -------------------------------------------------- alpha doubletype 1 beta doubletype 3.5 tau doubletype 10 -------------------------------------------------- Total number of dictionary entries: 3
Object types
There are a number of different object types in SLI. Each type is represented by a literal name (i.e. a name with a prepended slash). Here is a list of the most important types:
/integertype | /doubletype |
/booltype | /stringtype |
/nametype | /literaltype |
/arraytype | /proceduretype |
/modeltype | /dictionarytype |
/ostreamtype | /istreamtype |
/xistreamtype | /trietype |
Getting type information
The command type returns the type-name of the top element of the stack. Note that type removes the element.
The command typeinfo returns the type of an object without popping it off the stack.
Conversion between types
It is possible to perform conversions between types. However, unlike in C or C++ this type conversion is never done implicitly. Some of the conversion operators are inherited from PostScript. Others are special to SLI.
Here, we list the most important conversion operators. Each conversion operator gets one argument which can, in general, be of any type. If the operator is meaningless for a given object, an argumenttype error is raised.
| Command | Description |
|---|---|
cvd | Convert a number to a double. |
cvi | Convert a number to an integer. |
cvs | Tries to convert the object to a string. |
cst | Convert a string to an array. |
cvx | Convert an object to an executable object, e.g. string to a procedure, or a literal name to a name. |
cvlit | Convert an object to a literal object, e.g. a procedure to an array or a string to a literal name. |
