## Documentation Center |

Create an active copy of a frozen function

This functionality does not run in MATLAB.

`unfreeze(``object`)

`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.

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)

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 identifier`sum`:

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 environment`sum`, 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)

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))

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)

`freeze` returns an object of the same type
as `f`. `unfreeze` returns the evaluation
of `object` after reactivating all inactive functions
in it.

Was this topic helpful?