When writing code in any language, it is typically useful to include comments which clarify what the code is doing. In steve, there are two ways to include comments in code. A "single line" comment starts with a "#" is and continues to the end of the line; "multiline comments" are written starting with "#!" and ending with "!#". Some example of both kinds of comments are shown below:

        # this is a simple one-line comment.

        print "this is not a comment...".                # but this is.

        #!
                this
                is 
                a 
                multiline 
                comment
        !#

When building a class, you typically don't start from scratch—instead, you make the new class the child of an existing class. This is called creating a subclass. By subclassing a class, the new class will inherit all of the parent's methods and variables. This approach means that most of the difficult work will already be done by an existing breve class, and we can simply override and customize the behaviors that we need to.

For example, if we're building an object which will move through the 3D world, we'd like to have an object that understands the relationship between position, velocity and acceleration. Instead of implementing such a class ourselves, we can subclass Mobile.tz which is included with breve. Our custom subclass will contain the custom behaviors we desire, while the parent class takes care of the details.

When building a class, you must first decide the class name and its parent class. The parent class is the class from which the new class will inherit its behaviors. Classes which are to be used primarily for computation and do not require any special inherited behaviors, will typically use the generic root class Object. Classes which move around the world will inherit behaviors from Mobile, while immobile objects in the world will inherit behaviors from Stationary. A full list of classes is available in the appendix (???).

An empty class is simply defined by the following steve code:

parent_class_name : class_name {

}

Because we often deal with classes in their plural form (like when creating multiple instances of an object), it can be useful to give a class an alias which will allow us to refer to the class in its plural form. This is not required but may make code easier to read. This alias is defined by adding the text (aka alias_name) after the class name.

As an example of defining a class, both with and without an alias, consider a class called myMobile which will be a child of the class Mobile:

# first without the alias...

Mobile : myMobile {

}

# now with the alias...

Mobile : myMobile (aka myMobiles) {

}

This code above defines an empty class with no variables and no methods. This means that it will behave exactly as its parent class does. The next step is to customize the class's behavior by adding in methods and variables.

An instance variable is a variable associated with a class. Each instance of the class will have its own private copies of the class's instance variables.

Once the empty class declaration has been written, variables can be added using the heading + variables, followed by the list of instance variables. Variables are listed in the format variable_name (variable_type).

The variable name must start with a letter, but afterwards it may contain any alphanumeric characters, as well as the characters _ and -.

Multiple variables of the same type can also be declared on the same line:

variable1, variable2, variable3, ..., variableN (variableType). 

Variable types are covered in detail in the section Types (the section called “Types in "steve"”).

As an example, we'll add some variables to the simple class we created in the previous section:

Mobile : myMobile {
        + variables:
                myInt, myOtherInt (int).
                myObject (object).
                myFloat (float).
}

The most elementary method call in steve is a call to a method that takes no arguments. The definition of such a method is simple. Inside the definition of instanceName, we create a line:

+ to methodName:

The statements that follow this line will be part of the newly defined method until either the end of the object definition, or until the next method definition.

To define a method that takes arguments we will need the keyword, variable name and type of each argument. The keyword identifies the variable when it is being called, while the variable name is how the variable will be referenced from within the method. Finally, the type is simply the type of variable that will be passed in. The layout of this information is keyword, variable_name, (type), such that a method which takes one variable could be defined by the following line:

+ to set-velocity to-value theValue (float):

If the method takes two variables, we add another keyword/name/type triplet:

+ to set-rotation of-joint theJoint (Object) to-value theValue (float):

The code associated with the second method would then use the variables theJoint and theValue: "of-joint" and "to-value" are not actual variables, but instead the keywords which indicate which variables follows.

The calling convention of these methods is simple. After the instance name and method name, we give a list of keywords and values to be passed in. The order of the keyword/value pairs does not effect how the code is executed, though it may effect the readability of the code. The following lines call the set-rotation method which we defined above:

# the following lines are equivalent

myObject set-rotation of-joint myJoint to-value 200.
myObject set-rotation to-value 200 of-joint myJoint.

Methods may also have local variables associated with them. These variable definitions look just like class variable definitions, except that they follow after the method definition line, and not after the variable definition line. Method variables are automatically initialized to zero every time the method is called. Variable declarations in a method must precede all statements in the method.

For example, here is a simple method that uses local variables:

+ to find-closest-creature in creatureList (list):
        item (object).
        closestItem (object).
        distance (float).

        # we start with an unreasonably high "closestDistance" so that 
        # we are sure to find something closer.

        closestDistance = 1000000.

        foreach item in creatureList: {
                distance = |(self get-location) - (item get-location)|.

                if distance < closestDistance: {
                        closestItem = item.
                        closestDistance = distance.
                }
        }

        return closestItem.

- to methodName:

Method definitions may also specify optional arguments. Optional arguments are arguments that are given default values, and therefore do not need to be provided when calling the method. The use of optional arguments can greatly simplify writing code in steve.

To make an argument optional, you need to provide it with a default value. To do so, you'll need to modify the argument definition to include the text = value after the argument name. For example, a variable called theHeight with keyword with-height could be given a default value like this: with-height theHeight = 100 (int). Default values for optional arguments must be literal values (and not expressions or variables).

Below is an example of a method defined with a set of optional arguments.

        # Create a new agent, with some default values.

        + to create-new-agent with-color color = (1, 0, 0) (vector) 
                with-energy energy = 100 (int)
                with-radius radius = 10 (int) 
                with-name name = "agent" (string):

The method above could be called in a number of ways, optionally including or excluding each of the arguments:

        # no arguments 
        self create-new-agent.

        # some of the arguments 
        self create-new-agent with-energy 10 with-name "Becky".

        # all of the arguments
        self create-new-agent with-color (1, 1, 1) 
                with-energy 100
                with-radius 20
                with-name "Robert".

Certain method names have special meaning in steve, in that they are called automatically by the simulation at special times. These methods, in particular init and iterate are critical, as they are the entry-point into how your agents are initialized and how they will behave. These special method names are outlined below:

Creating a new instance of an object is called instantiating the object. Instantiating in steve is done using the new command. Instantiation creates a single new instance if no number is given, or as many objects as you want by preceding the command with a number. The syntax follows:

new object_type.
number new object_type.

If a single object is created, it is returned as an object type. If several are created, they are returned as a list. For example:

myBird (object).
myBugs (list).

myBird = new Bird.
myBugs = 100 new Bugs.

The method init is called automatically for a class and all of its superclasses when the class is instantiated.

Destroying instances is simply accomplished using the command free:

free instance.

free accepts both single instances and lists of instances.

If an instance frees itself, then execution of the code is stopped immediately, as though the free command was followed by a return.

When an object is freed, the destroy method is automatically called for the instance. Prior to version 1.9, destroy would automatically be called for all superclasses. This is no longer the case—you must call "super destroy" if you wish for the superclass destroy method to be run.

An int is a whole number, identical to the int type in C.

A real number, also known as "double", identical to the double type in C. Internally, floats are represented by 8-byte doubles.

An object is an instance of a steve class.

A vector is used to represent a point or vector in 3D space. A vector is expressed as three floating point numbers, such as (1.0, 2.0, 5.0).

v = (1, 2, 3).  # sets the vector to a constant vector.

v = v * 4.      # multiplies the vector by 4

v = v / |v|.    # normalizes the vector by dividing it by it's own 
                                # length such that the new length is 1.

xValue = myVector::x.

myVector::y = 100.

xValue = myVector{ 0 }.

myVector{ 1 } = 100.

A matrix in steve refers to a 3x3 matrix which describes a transformation in 3D space. Using transformation matrices is somewhat advanced and they are not generally used in most simulations. Still, they may be useful when dealing with physical simulations.

Matrices may be written in steve as three comma-separated vectors, enclosed in braces ('[' and ']'), as in this example:

# the matrix m will be initialized to:
#
# [ 1 2 3 ]
# [ 4 5 6 ]
# [ 7 8 9 ]

m = [ (1, 2, 3), (4, 5, 6), (7, 8, 9) ].

Matrix components can be extracted using the list index syntax. Each row of the matrix is a vector:

myVector = myMatrix{ 0 }.

myMatrix{ 1 } = ( 1, 2, 3 ).

Individual numbers may be extracted from matrices just as they are from two-dimensional lists:

myNumber = myMatrix{ 0 }{ 0 }.

myMatrix{ 1 }{ 1 } = 100.

The list datatype allows you to keep a list of other variables. lists can contain any datatype, including other lists. lists can even contain multiple datatypes simultaneously.

lists are formed using the syntax { item1, item2, ... }.

Some simple examples of constructing lists are shown below:

myList = { 1, 2, 3.0 }.                 # a list of numbers (both int and float)
myList = { "a", "b", "c" }.             # a list of strings
myList = { "a", 30, new Mobile }.       # a list of mixed types
myList = { 1, "a", { "dog", "cow" } }.  # a list with a nested list

An important feature of lists in steve is that they are always passed by reference and are not copied. This means that if you pass a list to a function, then any modifications done to the list inside the function will modify the original list.

myInt = (myList + 0).

The string type holds a character string. A string is written in code (as in C) as a quoted string. For example, the built-in print operator is capable of printing strings:

print "this is a string".

print "my value is $self.".

$longstring = "$string1$string2".

A hash is a type which works like a dictionary: it allows expressions ("values") to be stored and looked-up using other expressions as the "keys". The following example shows a steve hash being used like a dictionary:

dictionary (hash).

dictionary{ "dog" } = "a four-legged pet".
dictionary{ "fish" } = "a zero-legged pet".

# this will print the definition we stored above.

print "the definition of dog is: ", dictionary{ "dog" }.

As shown in this example, we're able to store data using strings as the keys. When data is later retrieved from the hash table using the same key, the value stored previously is returned.

hashes are not limited to using strings as keys. They can use any valid type. The most useful application is a hash table which uses objects as keys. In this way, relationships between objects can be stored in a hash. Consider an object that wants to keep track of neighbors it has encountered previously:

# let's say that this method gets called when a neighbor is seen...
# if the neighbor has already been seen, print a message — otherwise,
# just add it to the hash for next time!

+ to meet with neighbor (object):
        if seenHash{ neighbor }: print "I've seen this neighbor before!"
        else seenHash{ neighbor } = 1.

The example above also shows that the syntax of hashes is the same as the syntax for lists when storing or retrieving data. Unlike lists, however, hashes do not hold ordered data, and none of the other list operators work with hashes.

When using hashes with keys that are ints, floats, vectors, matrices or strings, steve will test the equivalence of the keyed data when looking up or storing the data. This means that two equivalent strings, even if they are stored in different variables, will refer to the same value in the hash. For the other types (objects, pointers, data, lists and hashes themselves), the hash will only return the same value for the same exact variable key. This means that two different lists, even if they contain "equal" data, will access different values in the hash.

An important feature of hashes in steve is that they are always passed by reference and are not copied. This means that if you pass a hash to a function, then any modifications done to the hash inside the function will modify the original hash.

foreach key in keys( myHash ): {
        print myHash{ key }.
}

pointer variables store C-style pointers to internal data. They are not used for writing simulations in steve and are only used by breve developers and plugin authors.

pointer variables are only useful in the context of interacting with internal C-style function calls: they do not contain methods, variables or any other meaning in the context of most steve code. Like objects, however, pointers can be tested to see if they are NULL (0), but cannot be used in mathematical expressions. That is to say that pointers have a meaning in a boolean context of control structures such as if and while (as well as the logical operators && and ||).

As in C, copying a pointer (assigning it to another variable) will not copy the data it points to.

data variables are similar to pointer variables in that they contain a reference to internal data. Also like pointer variables, they are not to be used in regular simulation code—they are only to be used by breve developers and custom plugins.

The difference between data and pointer is that data refers to a linear block of internal data of known size. This means that data variables can be successfully archived, while pointers cannot. The only use for data variables is archiving and dearchiving internal data. For more information on using the data type with plugins, see the section on Archiving Plugin Data With The data Type (the section called “Archiving Plugin Data With The data Type”).

Certain variables have special meanings in steve. Their values are managed automatically by the breve engine and should not be assigned manually.

The most simple expressions are simple assignments of literal values to variables. It may help to refer to the documentation on steve types before continuing.

Below are a few examples of this type of expression. In each case, the variable on the left will take the value of the expression on the right. If the expression on the right is not the correct type, it will be automatically converted if possible. If the conversion is not possible, an error will occur.

myInt = 4.
myDouble = 12.345.
myString = "Hello!".
    
# If we assign a double to an int, it will be automatically converted by 
# truncating the decimal portion.  In this example, myInt will take the value 
# 4:  
    
myInt = 4.8.
    
# Similarly, if we assign a string to an int or a double, the variable will
# take the numeric value of the string, in accordance with the atoi() or
# atof() ANSI C function.  Here the double will get the value 10000: 
     
myDouble = "10000 miles away.".

Mathematical operators in steve function almost exactly the same as they do in C, although there are some additions to account for vector and matrix types.

The following binary operators are valid for int and double types (the descriptions refer to x and y, as though they were used in an expression: x operator y):

Their functions should be self-explanatory, with the possible exception of modulus, which cannot be used with double types in C. When used with doubles, the result is calculated using the ANSI C fmod() function.

The following operators are valid for use with two vectors:

The following operators are valid for a vector and a double (although an int is automatically promoted to a double in this case):

As in many languages, parentheses are used to group expressions when the default order of operations does not compute the desired result:

# this is the default order, but we can make it explicit with parens
x = x + (4 / y).                    # computes 4 / y first...

# this is NOT the default order -- we need to force it
x = (x + 4) / y.                    # computes x + 4 first

Mathematical expressions are often used in conjunction with assignments in order to modify the value of a variable. A few examples of using mathematical expressions in conjunction with assignments follow:

    x = x + 4.

    y = (1, 2, 3) / x.                  # assumes x is an int or double

    z = z + x^2.

In addition to the mathematical assignment operators above, steve also support mathematical assignment operators. Mathematical assignment operators are used as shortcuts to perform a calculation and update the value of a variable simultaneously, instead of as two separate steps. These expressions are useful, but since they are only shortcuts for other expressions, understanding them is not critical.

The following mathematical assignment operators are available:

These operators are simply shortcuts for cases in which the left operand of the mathematical expression is also the location where the output of the expression will be stored. For example, the following expression pairs are equivalent:

a = a + b.               # "a equals a plus b" can also be written as...
a += b.                  # "a plus equals b"

a = a - (2, 2, 2).
a -= (2, 2, 2).

steve also has "increment" and "decrement" assignment operators:

As in languages like C and Perl, these operators increment and decrement a variable by one, respectively. Unlike C and Perl, these operators may only be placed after the variable. As an example, the following expression pairs are equivalent:

x = x + 1.          # updates the variable x by adding 1
x++.

x += 1.             # does the same...
x++.

y = (x += 1).       # a little confusing, but sets both x and y to (x + 1)
y = x++.            # as does this.

A number of internal functions (which are otherwise typically not used in breve simulations) are available for math-related expressions. Internal functions are called just like C functions: functionName (arguments).

The following internal functions are used for testing float variables for special values which have meaning primarily to developers and plugin authors.

Random numbers are available in steve using the command random. The syntax is random[ expression ], where expression is an expression of either int (the section called “The int type”), float (the section called “The float type”) or vector (the section called “The vector Type”). The value returned is always the same type as the expression. In the case of int or float, the returned value is a random value between 0 and the expression. In the case of a vector expression, the returned value is a vector in which each element is between 0 and the corresponding value of the expression. For example, a call to random[(10, 10, 20)] returns a vector with X and Y elements between 0 and 10, and the Z element between 0 and 20.

Note that random[intValue] returns a value between 0 and intValue, inclusive, as opposed to the behavior that many C programmers expect in which the returned value is between 0 and intValue - 1.

Because many simulations use the origin (0, 0, 0) as the "center" of their world, it is often useful to obtain a random vector centered around (0, 0, 0). For example, if we want to move agents somewhere within an imaginary box surrounding the origin, we might use the expression random[(40, 40, 40)] - (20, 20, 20). This convention gives us a vector with each element between -20 and 20. This type of expression appears frequently in simulations.

The values are produced using the standard C library rand() routine. The library is seeded with the current time when the breve application is launched. To explicitly set the random seed, you may call the internal function randomSeed( value ), where value is an integer.

In the event that multiple breve simulations are launched simultaneously (typically only relevant in cluster environments), it may be necessary to pick unique random seeds for each such simulation to prevent them from producing the exact same results. Refer to the Controller method set-random-seed-from-dev-random for more information on automatically picking unique random seeds on systems that support it.

As discussed in the section on defining class methods, each method is identified by a name and may have any number of input arguments. The most simple method call to a method with no arguments is simply:

instancemethodName.

If the method takes arguments, each argument is associated with a keyword: the keyword identifies which argument will follow and what it's type is. This is somewhat different from C where the argument's type and meaning is specified by its order relative to other arguments. The steve method is more similar to Objective C and allows a more natural language structure to method calls and protects against arguments being passed in the wrong order.

To pass arguments to the method, simply precede the argument value with the keyword name. Consider a method move-object which takes a keyword to:

myObject move-object to (1, 2, 3). 

If the method takes more than a single argument, the convention is the same—just add the next argument afterwards. Note that the order in which the arguments are passed does not affect the method call, though it may affect the readability of the code. For example, the Control object implements a method to point the camera at a certain vector location from a vector offset—first we'll see the method definition, then how it's called:

# if the method is defined using:
    
+ to point-camera at location (vector) from offset (vector):
    ...

# then from another method, we can call point-camera using the code below.
# these two method calls are equivalent, though the first reads more 
# naturally.

+ to do-something-else:
    self point-camera at (0, 0, 0) from (100, 100, 100).
    self point-camera from (100, 100, 100) at (0, 0, 0). 

If you wish to call a method for multiple objects, you can use the method call syntax with a list of objects. Note, however, that the arguments to the list are computed separately for each item in the list. This makes a difference in the following example:

# assume that mobileList is of type list

mobileList = 10 new Mobile.

# The random statement is evaluated for each instance, meaning that all the 
# instances go to different random locations, not to a single random location.

mobileList move to random[(20, 20, 20)].

You can find all instances of a given class using the all expression. all is given the name of a class, and returns a list containing all objects of that type.

# get a list of all mobile objects in the simulation

myMobile = all Mobiles.

The print and printf statements are used to print output from a simulation to the output log. Both of these statements accept any type of expression, as well as multiple expressions separated by commas. Also, since strings may contain embedded variables, you can format the output of variables however you'd like. See the section on strings (the section called “The string Type”) for more information.

The only difference between print and printf is that printf does not automatically print a newline character. This means that subsequent prints will continue on the same line (as though the "return" key was never hit). This can be useful if you're trying to produce output in a specific format, but is typically not desirable. If in doubt, stick to print

Here are some examples of print and printf:

# print two variables, side by side.

print (self get-time), populationSize.

# use a variable embedded in a string.

print "the population size is $populationSize".

# the following statements would produce the text:
# A B C
# D E F

print "A B C ".
print "D E F".

# the following statements would produce the text:
# A B C D E F

printf "A B C ".
printf "D E F".

As in C, of course, users can use subexpressions as part of larger expressions. For example, you can use a mathematical expression as part of a method call, or a method call as part of a mathematical expression. Because of the syntax of steve , however, subexpressions frequently need to be parenthesized in situations where it would not be required in C. The following important rules apply to using subexpressions: If a method call is not the entire statement, it must be parenthesized. If you wish to assign the result of a method call, use it in a mathematical expression or use it as an argument for another method, for example:

myInt = self get-speed.                   # incorrect
myInt = (self get-speed).                 # correct

myInt = self get-speed + 5.               # incorrect
myInt = (self get-speed) + 5.             # correct

self set-speed to neighbor get-speed.     # incorrect 
self set-speed to (neighbor get-speed).   # correct

All method arguments must be a single "unit"—arguments which are not simply a variable or literal value must be parenthesized.

This means that if you use mathematical expressions, instantiations or other method calls as input arguments to a method, they must be parenthesized. The first rule about method calls, of course, still applies:

self set-location to ((neighbor get-location) + (10, 10, 10)). # correct
self set-location to (neighbor get-location) + (10, 10, 10).   # incorrect

The final expression type is the internal function call. Internal function calls look just like C calls:

methodName(arg1,arg2, ... argN)

Although internal function calls grant the most direct access to the breve libraries and features, the included class hierarchy provides a formal interface to the internal functions such that user simulations should never use these internal functions. The only exception to this is for certain mathematical functions.

The if statement is used to execute one piece of code if a test statement is true, or (optionally) another if the statement is false:

if test_statement: true_code
[ else false_code ]

Examples of the if statement are shown below.

# here we execute a single statement

if x > 5: x = 20.
else x = 0.

# here we execute multiple...

if x > 5: {
        x = 20.
        y = 40.
} 

# here we execute multiple statements in the if, but only one in the else...

if x > 5: {
        x = 20.
        y = 40.
} else x = 200.

The while control structure works just like the while statement in C. While executes a block of code repeatedly, as long as the test condition is true:

while test_condition: code

An example of the while loop is shown below.

# for example...

while x < 10: {
        print "x = $x".
        x++.
}

The foreach control structure is similar to the foreach loop in Perl. The loop iterates through a list, and executes the associated code each time. The current item in the list is stored in a temporary variable as supplied by the user:

foreach temporary_variable in list_variable: code.

An example of the foreach loop is shown below.

# so, for example, if we have a variable called agent and a list
# of objects stored in agentList:

foreach agent in agentList: {
        print (agent get-location).
}

The for loop (similar to the for loop in C) repeatedly executes a block of code. Though it can function more generally like the while loop, it is typically used to run a block of code for each value of a "counter" variable.

The loop is separated into three statements—an initializer, a test statement, and an increment statement.

for expression, test_expression, increment_expression: code.

The initializer is executed once when the loop starts. It is typically used to set the iteration variable before proceeding. The test statement is run at every iteration to determine whether the loop will continue to execute (similar to the while loop). Finally, the increment statement is run at every iteration of the loop, typically to update a counter variable. Examples of the for loop are shown below.

# so, for example, if we have a variable called n (int), this loop will
# print the numbers from 0 to 29.

for n=0, n<30, n+=1: {
        print n.
}

# we can also use a different increment statement in order to run the 
# loop a bit differently—let's print only even numbers between 2 and 28

for n=2, n<=28, n+=2: {
        print n.
}

Memory management and garbage collection of basic types happens automatically and requires no user interaction. ints, floats, matrices and vectors are passed by reference and do not require garbage collection. lists, hashes and data are automatically garbage collected when appropriate.

breve's garbage collection is slightly complicated by the fact that objects do not need to be referenced in memory to be "in use". An unreferened object may, for example, "come back to life" because of an all (the section called “Finding All Objects of a Given Type”) expression. Furthermore, objects in the simulated world (members of subclasses of the class "Real") may physically interact even without referencing each other in their variables. Because of these complications, garbage collection cannot be automatically enabled for all objects in a simulation.

Garbage collection for objects is thus enabled on a per-object basis and the programmer must decide when its use is appropriate. The following guidelines should generally help to decide when garbage collection is appropriate for an object:

One important caveat applies to garbage collection of both basic types and objects. The steve garbage collection scheme does not correctly deallocate memory when there are circular references. A circular reference occurs when two (or more) objects refer to each other in a circular fashion. An example of a circular reference between three objects is shown below:

When a circular reference occurs, the objects are never recognized as "unused" and are thus never deleted as they should be. Circular references thus lead to "islands" of unused memory which do not get released. This type of circular reference is rare, but if your simulation design makes use of these types of structures, you may have to explicitly overwrite variables in order to ensure that no circular references exist.

breve includes a rich hierarchy of classes that are used to construct simulations. To use a class that comes with breve (or another file which you have created yourself), you must tell breve to load in its associated class file. You need to load a class before you instantiate it or subclass it.

Classes are loaded using the @include directive. It is used simply by specifying the name of the file to include:

@include "Control.tz".

@use works the same way, but with a slightly different syntax, leaving out the quotes and the ".tz" from the file name:

@use Control.

There is no difference between @include and @use in terms of how files are actually loaded.

@include directives are not only used to include classes that come with the breve distribution, but also potentially classes that you construct yourself. They are often used in conjunction with the @path directive (the section called “path: Specify a Search Path”) to specify the location of classes before loading them.

Each @path directive specifies a directory that breve should search within to find files. These directives apply to finding class files, image files, sound files, archives and any other type of resource that breve might need to search for. They should go at the top of source files, before any other files are included or used.

Here's an example @path directive that allows a folder containing class files to be searched:

@path "/Users/jk/breve_classes".

You may specify as many directories with @path directives as necessary.

A global constant lets you associate a name with a constant value in your simulation. The @define directive allows you to associate names with ints, floats and strings.

These constants can be very useful when you have the same value used several times in a simulation—then if you wanted to change the value, instead of making the change several times, you would make it once in the @define directive. They can also be useful for assigning meaningful symbols to numbers in your simulation. For example, if your cellular automata is arbitrarily chosen to be 50x50, then instead of hardcoding the number 50, it is more flexible and more descriptive to use a global constant.

Global constants are defined with the following form:

@define constant-nameconstant-value .

Here are some examples:

@define CA_SIZE                 50.
@define PI_VALUE                3.14159.
@define STRING_CONSTANT         "Hello".

By setting these constants at the top of the source file, you can use them later on. For example:

+ to print-pi:
        print "pi is approximately: ", PI_VALUE.

It is not required, but, by convention, global constants are typically written with all capital letters, to distinguish them from variables.