Ox Language Tutorial

Introduction

A first Ox program

Running the first Ox program

Linking multiple files

Variables, types and scope

Functions and function arguments

The for and while loops

The if statement

Operations and matrix programming

Arrays

Object-oriented programming

Style and Hungarian notation

Optimizing for speed

Hungarian notation prefixes

Hungarian notation, case sensitivity

Introduction

This chapter will give a brief overview of the important elements of the Ox language. A more formal description of the Ox syntax is in the syntax chapter.

The next section will introduce the first Ox program, showing the similarity between the syntax of Ox and that of the C language. (the standard reference for C is Kernighan and Ritchie, 1988) We shall see that a program always includes header files to define the standard library functions, and that it must have a main function, which is where program control starts. We shall also see that the body of the function is enclosed in curly braces.

A first Ox program

Ox is an object-oriented matrix language with a syntax similar to the C and C++ languages. This similarity is most clear in syntax items such as loops, functions, arrays and classes. A major difference is that Ox variables have no explicit type, and that special support for matrices is available. A comprehensive matrix function library is provided with Ox.

The advantages of object-oriented programming are that it potentially improves the clarity and maintainability of the code, as well as reducing coding effort through inheritance. Several useful classes are provided with Ox.

An Ox program consists of one or more source code files. As a first example consider the following small program (the code is in \ox\samples\myfirst.ox):

Running this first program will produce the following result:

The default extension of an Ox source code file is .ox, so the file name of this program could e.g. be myfirst.ox. The next section explains how to run the Ox program on your system. First we consider some aspects of the program.

• The first line includes the oxstd.h file into the source code (literally: the contents of the file are inserted at that point). This file contains the function declarations of the standard library, so that the function calls can be checked for number of arguments. The file name is between < >, indicating that the header file came with the Ox program.
• The function main is the starting point, and each program is only allowed one such function. Even though main has no arguments, it still requires ().
• Variables may be declared by using the decl statement, and have no type until the program is actually run.
• unit is a standard library function, which creates an identity matrix; here it is called with argument 3. The result is assigned to the variable m1. The type of m1 has become matrix, and until a reassignment is made (or it goes out of scope), m1 will keep its type and value.
• <0,0,0;1,1,1> is a matrix constant. Elements are listed by row, whereby rows are separated by a semicolon, and elements within a row by a colon. This value is stored in m2, which is now also of type matrix.
• print is a library function, which can print any type of variable or constant to the standard output screen. It can take any number of arguments. Here it has three: a string constant and two variables (which both happen to be matrices).

One important aspect of the C, C++ and Ox languages emerges from the program: array elements start at zero, so [0][0] is row 0, column 0, and [1][2] is row 1, column 2. This convention is also adopted the Ox language (but could be changed, see under pragmas.

The advantage of Ox over C here is that we can directly work with matrices, and do not have to worry about memory allocation and deallocation.

Running the first Ox program

MS-DOS compiler

Linux, Sun, HP compilers

Windows command-line compiler

Windows compiler (OxRun)

Filename:

the Ox program to compile

Link:

the object files to link in e.g. file1+file2+file3

Include/link path:

this field corresponds to the -I command line switch in Oxl, e.g.: c:/ox/include

Define:

arguments for the -D command line switch

OxRun and GiveWin are not part of the basic release of Ox.

Running programs with graphics

A graph can be saved in various formats:

encapsulated PostScript (.eps),

PostScript (.ps), and

GiveWin graphics file (.gwg).

MS-DOS graphics

Linux graphics

Windows graphics from the command-line

Windows graphics (OxRun and GiveWin)

Linking multiple files

File 1: myfunc.ox

File 1: myfunc.h

Including the code into the main file

File 3a: mymaina.ox

Separate compilation and linkage

File 3b: mymainb.ox

Separate compilation, including link file

File 3c: mymainc.ox

Variables, types and scope

Variables are declared using the decl keyword. Unlike C, variables are implicitly typed. This means that variables do not have a type when they are declared, but get a type when values are assigned to them. So a variable can change type during its lifetime. The most important implicit types are int for an integer value, double for a real number, string for a text string and matrix for a matrix (two-dimensional array) of real numbers.

The next Ox program illustrates implicit declaration and scope:

This prints (\n is the newline character):

The scope of a variable refers to the parts of the program which can see the variable. This could be different from its lifetime: a variable can be `alive' but not `seen'. If a variable is declared outside any function, its scope is the remainder of the source file. It is possible to export such variables to other source files, as we shall see shortly.

Variables declared inside a function have scope until the closing brace of the level at which it is declared. The following example illustrates:

The variable mX (here we use Hungarian notation, see Hungarian notation prefixes), can be seen everywhere in the main function. To make sure that it can never be seen in other source files, prefix it with the word static. It is good programming practice to use static in such cases, because it is very useful to know that it is not used in any other files (we may than rename it, e.g., without any unexpected side effects). An example was given in myfunc.ox on page \pageref{myfunc.ox}.

It is also possible to share variables between various source files, although there can be only one declaration (physical allocation) of the shared variable. The following modifications would do that for the myfunc.ox program: (1) delete the static keyword from the declaration, (2) add to myfunc.h the line:

Then any code which includes myfunc.h can reference or change the iCalls variable.

Functions and function arguments

We have already used various functions from the standard library (such as print, ones and zeros), and written several new ones (MyFunction, various main functions). Indeed, an Ox program is primarily a collection of functions. It is important to know that all function arguments are passed by value. This means that the function gets a copy which it can change without changing the original. For example:

which prints:

If the function argument is not changed by the function, it is good programming style to prefix it with the const keyword, as in:

Then the compiler can generate much more efficient code, especially for matrices and strings.

Of course it is possible to return changed values from the function. If there is only one return value, this is most simply done by using the return statement:

Another way is to pass a pointer to the variable, rather than the variable itself, as for example in:

which prints:

Now the change to ma is permanent. The argument to the function was the address of ma, and func received that address as a pointer. In C one could reference what is pointed to as *pmA or pmA[0]. In Ox only the latter is possible; we modified what that pointer referred to by assigning a value to pmA[0]. When func has finished, ma has been changed permanently. Note that we gave the argument a const qualification. This was possible because we did not change pmA itself, but what pmA pointed to.

The for and while loops

Since Ox is a matrix language, there is much less need for loop statements than in C or \Cpp. Indeed, because Ox is compiled and then interpreted, there is a speed penalty for using loop statements when they are not necessary.

The for, while and do while loops have the same syntax as in C. The for loop consists of three parts, an initialization part, a termination check, and an incrementation part. The while loops only have a termination check.

which prints:

This could also be written, less elegantly, using while as follows:

It is not uncommon to have more than one loop counter in the for statement, as the following code snippet illustrates:

The && is logical-and, whereas || is logical-or. The ++i statement is called (prefix) incrementation, and means `add one to i'. Similarly, --j subtracts one from j. There is a difference between prefix and postfix incrementation (decrementation). For example, the second line in

means: add one to i, and assign the result to j, which will get the value 4. But

means: leave the value of i on the stack for assignment, then afterwards increment i. So j will get the value 3. In the incrementation part of the for loop it does not matter whether you use the prefix or postfix form.

The if statement

The if statement allows for conditional program flow. In the following example we draw a uniform random number. Such a random number is always between zero and one. The ranu returns a matrix, unless we ask it to generate just one number. Then it returns a double, as is the case here.

Again, braces are used to group multiple statements together. They should also be used when nesting if statements, to avoid confusion about which else belongs to which if.

The if part is executed if the expression evaluates to a non-zero value (true). The else part otherwise, i.e. when the expression evaluates to zero (false: either an integer 0, or a double 0.0). Some care is required when using matrices in if statements. A matrix expression is a true statement if all elements are true (non-zero). Even if only one element is zero, the matrix expression is false, so

prints: yesnono.

There are two forms of relational operators. There is < <= > >= == != meaning `less', `less than or equal', `greater', `greater than or equal', `is equal' and `is not equal'. These always produce the integer value 1 (true) or 0 (false). If any of the arguments is a matrix, the result is only true if it is true for each element:

prints: yesnono.

The second form are the dot-relational operators .< .<= .> .>= .== .!= meaning `dot less', `dot less than or equal', `dot greater', `dot greater than or equal', `is dot equal' and `is not dot equal'. If any of the arguments is a matrix, the result is a matrix of zeros and ones, with each element indicating the relevant result.

The any library function returns 1 (true) if any element of the matrix is non-zero, so that yesyesno will be printed by:

To conclude: you can test whether all elements of a matrix m are equal to one (say) by writing: if (m == 1). To test whether any element is equal to one: if (any(m .== 1)). The expression if (m != 1), on the other hand, is only true if none of the elements is equal to one. So, use if (!(m == 1)) to test whether it is true that not all elements are equal to one.

Operations and matrix programming

To a large extent, the same operators are available in Ox as in C or C++. Some of the additional operators are power (^), horizontal concatenation (~), vertical concatenation (|) and the Kronecker product (**). One important distinction is that the operators are also available for matrices, so that, for example, two matrices can be added up directly. For some operators, such as multiplication, there is a distinction between the dot operators (e.g. .* is element by element multiplication and * is matrix multiplication if both arguments are matrices). Not available in Ox are the bitwise operators, instead you need to use the library functions binand and binor.

Because Ox is implicitly typed, the result type of the expression will depend on the types of the variables in the expression. When a mixture of types is involved, the result is promoted upwards in the order integer, double, matrix. So in an expression consisting if an integer and a double, the integer will be promoted to a double. An expression of only integers yields an integer. However, there are two important exceptions to this rule:

• integer division is done in floating point and yields a double. This is an important difference with C, where integer division is truncated to an integer.
• power expressions involving integers which yield a result too large to be expressed as an integer give a double result.

To illustrate, we write the Fahrenheit to Celsius example of Kernighan and Ritchie (1988) in Ox:

which prints:

In C we have to write 5.0/9.0, because 5/9 evaluates to zero. In Ox both expressions would be evaluated in floating point arithmetic.

In general we get more more efficient code by vectorizing each program as much as possible:

• As in the first version of the program, we declare three constants which define the Fahrenheit part of the table.
• The range() function creates a 1 by n matrix with the values LOWER, LOWER+STEP, LOWER + 2STEP, ..., UPPER.
• The transpose operator ' changes this into an n by 1 matrix.
• The conversion to Celsius in the print statement works on the matrix as a whole: multiplication of a matrix by a scalar is equivalent to multiplication by the scalar of each element of the matrix.
• The ~ operator concatenates the two column vectors into an n by 2 matrix.
• Finally, the print function is different from the printf in C. In Ox each variable to print is simply specified sequentially. It is possible, as done here with "%6.1f", to insert formatting strings for the next variable.

The program prints a table similar to the earlier output:

Arrays

The Ox syntax allows for arrays, so you may use, for example, an array of strings (often useful), an array of matrices, or even an array of an array of matrices (etc.). The following program gives an example.

which prints

• The new operator declares a new object. That could be a class object, as discussed in the next chapter, a matrix, a string, or, as used here, an array. The argument in square brackets is the size of the array. (When creating a matrix in this way, note that a matrix is always two-dimensional, and needs two arguments, as in: m = new matrix[2][2].)
• The sprint functions return a string, which is stored in the arrays.
• In print(), we use "%r" followed by an array of strings to specify row labels for the subsequent matrix. Columns labels use "%c".

Object-oriented programming

In some of the literature of recent years it has been claimed that object-oriented programming would solve all programming problems. My claims here are more modest. I see it as a useful addition, but believe thoughtless application could actually result in less readable programs. You may completely ignore the object-oriented features. However, you will then not be able to use the preprogrammed classes for data management and simulation. It is especially in the latter task that I found a considerable reduction in the required programming effort after writing the base class.

One of the drawbacks of C++, as compared with C, is that it is a much larger and considerably more complicated language, with all the extra overhead used for the object-oriented features. The standardization of C++ is also as yet an unfinished process. Ox only implements a subset of the C++ features. I tend to see that as a benefit rather than a drawback.

The class is the main vehicle for object-oriented programming. A class is nothing more than a group of variables (the data) and functions (the actions) packaged together. This makes it a supercharged struct (or record in Pascal terminology). Inheritance allows for a new class to add data and functions to the base class, or even redefine functionality of the base class.

In Ox, all data members of the class are private (only visible to class members), and all function members are public. Like C++, Ox has the virtual keyword to define functions which can be replaced by the derived class. Classes are used by dynamically creating objects of that class. No static objects exist in Ox. When an object is created, the constructor function is called, when the object is deleted, the destructor function is called.

The encapsulation of data in classes removes the need for global variables. This is an important advantage: a proliferation of global variables makes programs very difficult to maintain. That is also why it is important to make external variables which are specific to one file static.

More information on object-oriented programming is given in the classes section.

Style and Hungarian notation

The readability and maintainability of a program is considerably enhanced when using a consistent style and notation, together with proper indentation and documentation. Style is a personal matter; this section describes the one I have adopted.

In my code, I always indent by four spaces at the next level of control (i.e. after each opening brace), jumping back on the closing brace.

Table tut.1: Hungarian notation prefixes

I have found Hungarian notation especially useful (see e.g. Petzold, 1992, Ch. 1). Hungarian notation involves the decoration of variable names. There are two elements to Hungarian notation: prefixing of variable names to indicate type (Table tut.1), and using case to indicate scope (Table tut.2, remember that Ox is case sensitive).

Table tut.2: Hungarian notation, case sensitivity

As an example consider:

Func2 expects a cT by cX matrix, and corresponding array of cX variable names. The c prefix is used for the number of elements in a matrix or string. Note however, that it is not necessary in Ox to pass dimensions separately. You can ask mX and asX what dimensions they have:

Optimizing for speed

Ox is very fast: current benchmarks suggest that it is faster than several other commonly used matrix language interpreters. A program can never be fast enough though, and here are some tips to achieve higher speed:

• Use matrices as much as you can, avoiding loops and matrix indexing.
• Use the const argument qualifier when an argument is not changed in a function: this allows for more efficient function calling.
• Use built-in functions where possible.
• When optimizing a program with loops, it usually only pays to optimize the inner most loop. One option is to move loop invariants to a variable outside the loop.
• Avoid using `hat' matrices, i.e. avoid using outer products over large dimensions when not necessary.
• If necessary, you can link in C or Fortran code, see the appendix on Extending Ox in the written documentation.
• Note that matrices are stored by row (the C and C++ default, but transposed from the Fortran default), so it could sometimes be faster to transpose matrices (i.e. have data variables in rows instead of columns).
• If necessary, you can link in C or Fortran code, see the appendix on Extending Ox in the written documentation.

References

Kernighan, B.W. and Ritchie, D.M. (1988). The C Programming Language 2nd Ed. Englewood Cliffs, NJ: Prentice Hall.

Petzold, C. (1992). Programming Windows 3.1. Redmond: Microsoft Press.