Documentation

## Procedures

MuPAD® notebooks will be removed in a future release. Use MATLAB® live scripts instead.

MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.

### Create a Procedure

If you want to execute a piece of code repeatedly, create and use a procedure. Define a procedure with the `proc` command. Enclose your code in the `begin` and `end_proc` commands:

```myProc:= proc(n) begin if n = 1 or n = 0 then 1 else n * myProc(n - 1) end_if; end_proc:```

Use `end` as a shortcut for `end_proc`.

### Call a Procedure

Now call the procedure:

`myProc(5)`

### Control Return Values

By default, a procedure returns the result of the last executed command. If you want to return other results, use the `return` command. For example, create a procedure that computes the factorials of integer numbers:

```myProcReturn := proc(n) begin if n = 0 or n = 1 then return(1); end_if; n * myProcReturn(n - 1); end_proc:```

Call the procedure:

`myProcReturn(5)`

To display the results on your screen without returning them, use the `print` command:

```myProcPrint:= proc(n) begin print(n); if n = 0 or n = 1 then return(1); end_if; n * myProcPrint(n - 1); end_proc:```

Call the procedure:

`myProcPrint(5);`

### Return Multiple Results

To return several results from a procedure, use such structures as lists or matrices as return values:

```myProcSort:= proc(a, b) begin if a < b then [a, b] else [b, a] end_if; end_proc:```
`myProcSort(4/5, 5/7)`

### Return Symbolic Calls

Many built-in MuPAD® procedures can return symbolic calls to themselves when they cannot compute results as exact values. For example, when you compute `sin(PI/2)`, the `sin` function returns the exact value 1. At the same time, when you compute `sin(x/2)`, the `sin` function returns the symbolic call to itself:

`sin(x/2)`

To enable your custom procedure to return symbolic calls, use the special syntax `procname(args())`. For example, create the procedure that computes a factorial of its argument:

```f := proc(x) begin if testtype(x, Type::PosInt) then return(x!) else return(procname(args())) end_if: end_proc:```

If its argument is a positive integer, this procedure returns an exact number:

`f(5), f(10)`

Otherwise, it does not error, but returns a symbolic call to itself:

`f(1/3), f(1.1), f(x), f(x + 1)`

### Use Global and Local Variables

Inside a procedure, all variables fall into two categories: global and local. Global variables are accessible from everywhere inside a notebook. Local variables are accessible only from within a procedure.

#### Global Variables

Suppose you want to create a procedure `gProc` and use the global variable `gVar` inside the procedure:

```gProc := proc(x) begin gVar := gVar^2 + x^2 + 1 end_proc:```

When you call this procedure, the value of the variable `gVar` changes:

```gVar := 10; gProc(5): gVar```

Multiple calls change the value of the global variable further:

```gProc(5): gVar```

### Note

Avoid using unnecessary global variables.

Global variables reduce code readability, occupy the global namespace, and often lead to errors. When you use global variables inside a procedure, always verify that each call to the procedure changes global variables as intended.

#### Local Variables

You can access and modify local variables only inside a procedure. Suppose, you use a variable `lVar` in your notebook:

`lVar := 10`

To declare a local variable, use the `local` command inside a procedure:

```lProc := proc(x) local lVar; begin lVar := 10; lVar := lVar^2 + x^2 + 1 end_proc:```

When you call this procedure, the value of the variable `lVar` changes only inside a procedure. Outside the procedure, the variable does not change its value:

```lProc(5): lVar```

If you declare a local variable, it does not inherit the value of a global variable with the same name. Local variables are not identifiers of type `DOM_IDENT`. They belong to a special domain type `DOM_VAR`. Therefore, you cannot use a local variable as a symbolic variable. Before performing computations with a local variable, you must assign a value to that variable. For example, without the assignment `lVar:= 10`, the procedure call `lProc` returns an error message:

```lProc := proc(x) local lVar; begin lVar := lVar^2 + x^2 + 1 end_proc:```
`lProc(5)`
```Warning: Uninitialized variable 'lVar' is used. Evaluating: lProc ```
```Error: Invalid operand. [_power] Evaluating: lProc ```

Local variables cannot have assumptions.

### Restore Values and Properties of Global Variables Modified in Procedures

When you use global variables inside a procedure, you can save their original values and properties, and recover them after the procedure. Suppose, you want to use more decimal digits for calculations with floating-point numbers inside a procedure. By default, the number of digits is 10:

`DIGITS`

To save this default value, use the `save` command at the beginning of the procedure:

```myProcSave := proc(newDigits, x) save DIGITS; begin DIGITS := newDigits; print(float(x)); end_proc:```

After you call the procedure `myProcSave`, MuPAD restores the value of the global variable `DIGITS`:

```myProcSave(20, PI); DIGITS```

The combination of `save` and `delete` lets you temporarily free the variable for the use inside a procedure. For example, the procedure cannot use the variable `x` because the variable has a value assigned to it:

```x := 10: proc() begin solve(x^2 + x = 1, x) end_proc();```
```Error: Invalid variable to solve for. [solve] ```

Use the `save` command to save the original value 10. Then, free the variable `x` using the `delete` command:

```x := 10: proc() save x; begin delete x; solve(x^2 + x = 1, x) end_proc()```

After the procedure call, MuPAD restores the original value of `x`:

`x`

The `save` and `delete` combination is helpful when you want to use a symbolic variable (without any value assigned to it) inside a procedure. You cannot use local variables for that purpose because a local variable in MuPAD is not an identifier. A local variable must have a value assigned to it. Also, you cannot specify assumptions on local variables, and you cannot integrate with respect to local variables.

#### Mathematical Modeling with Symbolic Math Toolbox

Get examples and videos