:orphan:

.. _obj_data_sli:

Objects and data types
======================

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 1
~~~~~~~~~~

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 2
~~~~~~~~~~

::

   [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]\)

::

   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 association between a name an
an object.

Example 3
~~~~~~~~~

::

   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 4
~~~~~~~~~

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.

Example 5
~~~~~~~~~

::

   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. Instead, 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 6
~~~~~~~~~

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 argument type 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.
