Documentation

freeze

Create an inactive copy of a function

Use only in the MuPAD Notebook Interface.

This functionality does not run in MATLAB.

Syntax

freeze(f)

Description

freeze(f) creates an inactive copy of the function f.

ff := freeze(f) returns a function that is an "inactive" copy of the argument f. This means:

  1. ff only evaluates its arguments, but does not compute anything else,

  2. ff is printed in the same way as f,

  3. symbolic ff calls have the same type as symbolic f calls,

  4. if f is a function environment, then ff has all the slots of f.

ff evaluates its incoming parameters even if the function f has the procedure option hold.

Use freeze when you want to perform many operations with f that require f only in its symbolic form, but f need not be executed.

Neither eval nor level can enforce the evaluation of an inactive function. See Example 2.

Examples

Example 1

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 all information that is known about the function int, for example, 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

This example shows 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 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

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 can contain the original function f.

For example, if you 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))

Parameters

f

A procedure or a function environment

Return Values

An object of the same type as f.

See Also

MuPAD Functions

Was this topic helpful?