Home Overview Documents Content Dictionaries Software & Tools The OpenMath Society OpenMath Projects OpenMath Discussion Lists OpenMath Meetings Links

# OpenMath Content Dictionary: prog1

Canonical URL:
http://www.openmath.org/cd/prog1.ocd
CD Base:
http://www.openmath.org/cd
CD File:
prog1.ocd
CD as XML Encoded OpenMath:
prog1.omcd
Defines:
assignment, block, call_arguments, def_arguments, for, function_block, function_call, function_definition, global_var, if, local_var, procedure_block, procedure_call, procedure_definition, while, return
Date:
2001-02-16
Version:
0 (Revision 1)
Review Date:
2001-06-01
Status:
experimental
Uses CD:
arith1, quant1, relation1

A CD for basic algorithmic concepts. We define the minimal machinery to write small programs in OpenMath encoding.

## assignment

Description:

This symbol is used to assign values to variables. The syntax is assignment(variable, value), where variable is the encoding of an OpenMath variable (OMV) and value is an OpenMath object.

Example:
The assignment a := 125 is encoded as
$\mathrm{assignment}\left(a,125\right)$
Signatures:
sts

 [Next: block] [Last: procedure_block] [Top]

## block

Description:

This symbol is meant to represent an arbitray block of code. A block of code can be empty. The syntax is block(obj1, obj2,...,objN), where obji is the OpenMath encoding of the ith sentence (or action) inside the body.

Example:
The following block of code { a := 153; a := a+1; } is encoded as
$\mathrm{block}\left(\mathrm{assignment}\left(a,153\right),\mathrm{assignment}\left(a,a\right)\right)$
Signatures:
sts

 [Next: local_var] [Previous: assignment] [Top]

## local_var

Description:

This symbol can be used to declare local variables.

Signatures:
sts

 [Next: global_var] [Previous: block] [Top]

## global_var

Description:

This symbol can be used to declare global variables as know to function.

Signatures:
sts

 [Next: return] [Previous: local_var] [Top]

## return

Description:

This symbol can be used to return values from fuctions.

Signatures:
sts

 [Next: for] [Previous: global_var] [Top]

## for

Description:

This symbol can be used to encode the for loop. The syntax is for(block1,conditional_block,block3,block4), where block1 is the inicialization block, conditional_block is the conditional block that determines the end of the loop, block3 is the incremental block and block4 is the body of the for loop. Each of this blocks should be present (althougth they can be empty).

Signatures:
sts

 [Next: while] [Previous: return] [Top]

## while

Description:

The symbol the while loop. The syntax is while(conditional_block, block1), where conditional_block is the block that determines when to stop the while loop and block1 is the body of the while loop.

Signatures:
sts

 [Next: if] [Previous: for] [Top]

## if

Description:

The symbol can be used to encode the if, then, else construct. The syntax is if(conditional_block,block1,block2), where the conditional_block is the block that determines wich of the block of codes block1 and block2 is going to be executed, block1 is the then block and block2 if the else block. The conditional_block and block1 are required but block2 is optional.

Signatures:
sts

 [Next: call_arguments] [Previous: while] [Top]

## call_arguments

Description:

This symbol can be used to encode the arguments that will be pased to a function or procedure.

Signatures:
sts

 [Next: def_arguments] [Previous: if] [Top]

## def_arguments

Description:

This symbol can be used to encode the arguments that a function or procedure can receive.

Signatures:
sts

 [Next: function_block] [Previous: call_arguments] [Top]

## function_block

Description:

The block of code defining the body of the function. The syntax is function_block(local_var,block1), where local_var encodes the local variables (private to the function body) and block1 is the body of the function. Both locar_var and block1 should be present (and of course both can be also empty).

Signatures:
sts

 [Next: function_definition] [Previous: def_arguments] [Top]

## function_definition

Description:

The symbol function_definition can be is used to define a function. The syntax is function_definition(name, def_arguments, function_block), where name is the encoding of an OpenMath variable (OMV) representing the name of the funtion, def_arguments is the enconding of the arguments that the function receives and function_block is the body of the function (local variables declarations + body of the function). Functions are completely unaware of the rest of the "world" except for the information they received from the arguments. Functions are only allowed to return values by means of the return construct.

Example:
The function (in Maple notation), MyFunction:=proc(N) local i, Result; Result := 1; for i from 2 to N do Result := Result + i^10; od; Result; end;, is encoded as
$\mathrm{function_definition}\left(\mathrm{MyFunct},\mathrm{def_arguments}\left(N\right),\mathrm{function_block}\left(\mathrm{local_var}\left(i,\mathrm{Result}\right),\mathrm{block}\left(\mathrm{assignment}\left(\mathrm{Result},1\right),\mathrm{for}\left(\mathrm{block}\left(\mathrm{assignment}\left(i,2\right)\right),\mathrm{block}\left(i\le N\right),\mathrm{block}\left(\mathrm{assignment}\left(i,i+1\right)\right),\mathrm{block}\left(\mathrm{assignment}\left(\mathrm{Result},{i}^{10}+1\right)\right)\right),\mathrm{return}\left(\mathrm{Result}\right)\right)\right)\right)$
Example:
The encoding of a function N --> 1+2^3+...+N^3 (uses the while loop) is
$\mathrm{function_definition}\left(\mathrm{Prog1AddCubes},\mathrm{def_arguments}\left(n\right),\mathrm{function_block}\left(\mathrm{local_var}\left(\mathrm{Total},i\right),\mathrm{block}\left(\mathrm{assignment}\left(i,1\right),\mathrm{assignment}\left(\mathrm{Total},0\right),\mathrm{while}\left(\mathrm{block}\left(i\le n\right),\mathrm{block}\left(\mathrm{assignment}\left(\mathrm{Total},\mathrm{Total}+{i}^{3}\right),\mathrm{assignment}\left(i,i+1\right)\right)\right),\mathrm{return}\left(\mathrm{Total}\right)\right)\right)\right)$
Example:
The encoding of a function the compute the Nth term of the Fibonacci sequence is
$\mathrm{function_definition}\left(\mathrm{Prog1Fibonacci},\mathrm{def_arguments}\left(n\right),\mathrm{function_block}\left(\mathrm{local_var}\left(\right),\mathrm{block}\left(\mathrm{if}\left(\mathrm{block}\left(\left(n=1\right)\vee \left(n=2\right)\right),\mathrm{block}\left(\mathrm{return}\left(1\right)\right),\mathrm{block}\left(\mathrm{return}\left(\mathrm{function_call}\left(\mathrm{Prog1Fibonacci},\mathrm{call_arguments}\left(n-1\right)\right)+\mathrm{function_call}\left(\mathrm{Prog1Fibonacci},\mathrm{call_arguments}\left(n-2\right)\right)\right)\right)\right)\right)\right)\right)$
Signatures:
sts

 [Next: function_call] [Previous: function_block] [Top]

## function_call

Description:

Symbol function_call can be used to "call" already defined functions. The syntax is function_call(name, call_arguments), where name is the encoding of an OpenMath variable (OMV) representing the name of the function and call_arguments are the arguments to pass to the function. Both, name and call_arguments, should be present but call_arguments can be empty.

Example:
The function call "MyFunction(100)" is encoded as
$\mathrm{function_call}\left(\mathrm{MyFunct},\mathrm{call_arguments}\left(100\right)\right)$
Signatures:
sts

 [Next: procedure_definition] [Previous: function_definition] [Top]

## procedure_definition

Description:

This symbol can be used to define a procedure. The sintax is procedure_definition(name, def_arguments, procedure_block), where name is the encoding of an OpenMath variable representing the name of the procedure, def_arguments encodes the argument the procedure can receive and procedure_block encodes the body of the procedure. Contrary to function procedures can have knowledge about global objects by means of the global_var construct (see procedure block).

Signatures:
sts

 [Next: procedure_call] [Previous: function_call] [Top]

## procedure_call

Description:

Symbol procedure_call can be used to "call" already defined procedures. The syntax is procedure_call(name, call_arguments), where name is the encoding of an OpenMath variable (OMV) representing the name of the function and call_arguments are the arguments to pass to the function. Both, name and call_arguments, should be present but call_arguments can be empty.

Signatures:
sts

 [Next: procedure_block] [Previous: procedure_definition] [Top]

## procedure_block

Description:

The block of code defining the body of the procedure. The syntax is procedure_block(local_var, global_var, block1), where local_var encodes the local variables (private to the procedure body), gloval_var are global variables that are know to the procedure and block1 is the body of the procedure. All these elements, locar_var, global_var and block1, should be present (but they can also be empty).

Signatures:
sts

 [First: assignment] [Previous: procedure_call] [Top]

 Home Overview Documents Content Dictionaries Software & Tools The OpenMath Society OpenMath Projects OpenMath Discussion Lists OpenMath Meetings Links