However, everything so far has carried out calculations already determined before the program is running. Another way of saying this is that, so far, the operations have been hard coded into the .ox program and not dependent on the data itself.

Now we introduce aspects of Ox that allow a program to be a contingent plan to deal with input that is not known until after the program is running. To make this easier to explain we need a way to provide input to the program that is not hard-coded. There are many ways in Ox to read in data from files, and most serious computational economics would rely on this kind of data input. However, to emphasize reaction to input we introduce the Ox method for asking for input from the keyboard interactively. This method is the scan() function.

05-scan.ox
 1:    #include "oxstd.h"
 2:    main() {
 3:        decl x=0;
 4:        scan("Enter x: %g",&x);
 5:        println("Ok, x= ",x);
 6:        }

There are two bits of syntax in the program that we will only discuss later, namely %g and &x. Essentially, %g says that the person should enter a real number (not a name or other kind of input), and &x says to put the number entered into the variable x.

Our first compound Ox statement is the if statement. A compound statement is one made up of two or more other statements, just like English. If I study for the test then I can pass the course. is a sentence made up of two complete sentences with some extra glue that ties them together: the special words if and then. An Ox if statement is similar except you do not include then in your code. The simple if statement has the form

if ( «condition» ) «statement»

Meanwhile, if is a keyword that plays the role like an operator even though it is not a symbol. Note that the round brackets are required parts of the syntax. This is often called a if-then statement, although in Ox there is no then keyword. Only if appears, and the then part is whatever comes after ")".

When learning to program, it helps to visualize how the program will execute. A way to this is to create a flowchart for the program. There are standard symbols for structures like an if statement. In flowcharts, a test of a condition is represented by a diamond shape ◆. The possible results of the test are given by arrows out of the diamond marked Yes and No or sometimes TRUE and FALSE.

Exhibit 3. Flowchart for If-Then Code

The condition is an expression that is tested for being TRUE or FALSE. If it is TRUE then the statement is executed. If it is FALSE then the statement is skipped and the next statement in the program is executed. Here is an example in Ox:

05a-scanX.ox
 1:    #include "oxstd.h"
 2:    main() {
 3:        decl x;
 4:        scan("Enter x: %g",&x);
 5:        if (x < 1.0) {
 6:    		println("x is less than 1.0");
 7:    		println("So we are in trouble");
 8:    		}
 9:    	else
10:    		println("We are all set");
11:        println("Finished");
12:        }    	

{
    statement_1;
    statement_2;
    ⋮
}

Here the brackets create a single statement from 0 or more statements. A use of brackets to create a more complex program could look like this:

05b-scanX.ox
 1:    #include "oxstd.h"
 2:    main() {
 3:        decl x;
 4:        scan("Enter x: %g",&x);
 5:        if (x < 1.0) {
 6:            println("x is less than 1.0");
 7:            if (x < 0.0)
 8:               println("In fact, it is less than 0!");
 9:            }
10:        println("Finished");
11:        }    	

This feature of Ox, that brackets create blocks of code and indentation only helps a human reader is completely different than Python. In Python the indentations matter because they create the blocks of code.

Exhibit 4. Flowchart for If-Then-Else Code

Programming code is sequential. So the if-block comes before the else-block in the code. Only one block will be executed. The computer has to skip or jump over the block that is not executed. Thus, in Ox you have the option of adding an else component to your if statement. Now the compound statement is formed from two statements (which again can each be blocks of statements). The format is

    if («condition») «statement» else «statement»

Here is a simple example in Ox:

    ⋮
    scan("Enter x: %g",&x);
    if (x < 1.0)
        println("x is less than 1.0");
    else
        println("x is at least as big as 1.0");

    if (x < 1.0)
        println("x is less than 1.0");
    else if (x < 2.0)
        println("x lies between 1.0 and 2.0");
    else
        println("x is at least as big as 2.0");

if (x < 1.0)
    println("x is less than 1.0");
else {
    if (x < 2.0)
        println("x lies between 1.0 and 2.0");
    else
        println("x is at least as big as 2.0");
    }

One of the basic uses of if() is to make the value of a variable depend on some condition that is checked when the program is running. For example, perhaps the rest of the program does different things depending on whether the value of x entered from the keyboard is negative or not. Rather than checking it over and over again we can define a variable that carries this information:

decl xispos;
scan("Enter x: %g",&x);
if (x < 0.0)
    xispos = FALSE;
else
    xispos = TRUE;
⋮
if (xispos) {
    // handle positive values
    }
else {
    // handle negative values
    }

decl V
scan("Enter V: %g",&V);
if (V >= 0) {
    if (V <= 100 ) {
        println("V is valid");
        }
    else {
        println("V is too big");
        }
    }
else {
        println("V is negative");
        }

decl V
scan("Enter V: %g",&V);
if (V >= 0 && V <= 100) {
        println("V is valid");
else {
        println("V is invalid");
        }

The if-then and if-then-else statements are essential parts of Ox and any programming language. The sections below discuss two useful but not necessary features of Ox that allow you to specialize the if statement and simplify many related if-then-else conditions.

xispos = x > 0 ? TRUE : FALSE;

«cond1» ? «val-0»
        : ( «cond2» ? «val-1»
                    : «val-2»);

switch_single ( «integer» ) {
    case «val-0» :  statement-block;
    case «val-1» :  statement-block;
    ⋮
    case «val-k» :  statement-block;
    default : statement-block;
    }

Because all the cases are surrounded by { } the individual statement blocks inside the switch_single do not require curly brackets around them. Ox knows the block ends once it finds another case.

You can code as many different cases as you need. But there are a lot of integers so you don't have to provide cases for integers that can't happen in your code. Further, you may be a bunch cases that all result in the same stuff to do. You can say what to do for all other cases by specifying the default case. The statement block will end once the right bracket that matches the one that started it all is found.

switch_single (i) {
    case 0:
        println("zero");
    case 1:
        println("one");
    case 2:
        println("two");
    default:
        println("i is something other than 0, 1, or 2");
    }