Accelerating the pace of engineering and science

# Documentation Center

• Trial Software

# unfreeze

Create an active copy of a frozen function

### Use only in the MuPAD Notebook Interface.

This functionality does not run in MATLAB.

## Syntax

```unfreeze(object)
```

## Description

unfreeze(object) reactivates all inactive functions occurring in object, proceeding recursively along the structure of object, and then evaluates the result.

unfreeze uses misc::maprec to proceed recursively along the structure of object. This means that for basic domains such as arrays, tables, lists, or polynomials, the function unfreeze is applied to each operand of object.

Note that if object is an element of a library domain, then the behavior of unfreeze is specified by the method "maprec" which overloads the function misc::maprec. If this method does not exist, then unfreeze has no effect on object. See Example 4.

unfreeze does not operate on the body of procedures, therefore it is recommended not to embed inactive functions inside procedures.

## Examples

### Example 1

We create an inactive form of the function environment int:

`_int := freeze(int): F := _int(x*exp(x^2), x = 0..1)`

The inactive form of int keeps every information that is known about the function int, e.g., the output, the type, and the "float" slot for floating-point evaluation:

`F, type(F), float(F)`

The original function environment int is not modified by freeze:

`int(x*exp(x^2), x = 0..1)`

Use unfreeze to reactivate the inactive function _int and evaluate the result:

`unfreeze(F), unfreeze(F + 1/2)`

### Example 2

We demonstrate the difference between hold and freeze. The result of the command S := hold(sum)(...) does not contain an inactive version of sum, but the unevaluated identifiersum:

`S := hold(sum)(1/n^2, n = 1..infinity)`

The next time S is evaluated, the identifier sum is replaced by its value, the function environmentsum, and the procedure computing the value of the infinite sum is invoked:

`S`

In contrast, evaluation of the result of freeze does not lead to an evaluation of the inactive function:

`S := freeze(sum)(1/n^2, n = 1..infinity)`

`S`

An inactive function does not even react to eval:

`eval(S)`

The only way to undo a freeze is to use unfreeze, which reactivates the inactive function in S and then evaluates the result:

`unfreeze(S)`

### Example 3

Note that freeze(f) does not change the object f but returns a copy of f in an inactive form. This means that computations with the inactive version of f may contain the original function f.

For example, if we create an inactive version of the sine function:

`Sin := freeze(sin):`

and expand the term Sin(x+y), then the result is expressed in terms of the (original) sine function sin:

`expand(Sin(x + y))`

### Example 4

The function unfreeze uses misc::maprec to operate recursively along the structure of object. For example, if object is an array containing inactive functions, such as:

```a := array(1..2,
[freeze(int)(sin(x), x = 0..2*PI), freeze(sum)(k^2, k = 1..n)]
)```

then unfreeze(a) operates on the operands of a:

`unfreeze(a)`

This means that for library domains, the effect of unfreeze is specified by the method "maprec". If the domain does not implement this method, then unfreeze does not operate on the objects of this domain. For example, we create a dummy domain and an object containing an inactive function as its operand:

```dummy := newDomain("dummy"):
o := new(dummy, freeze(int)(sin(x), x = 0..2*PI))```

The function unfreeze applied to the object o has no effect:

`unfreeze(o)`

If we overload the function misc::maprec in order to operate on the first operand of objects of the domain dummy, then unfreeze operates on o as desired:

```dummy::maprec :=
x -> extsubsop(x,
1 = misc::maprec(extop(x,1), args(2..args(0)))
):
unfreeze(o)```