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

Any MuPAD^{®} object 
freeze
returns an object of the same type
as f
. unfreeze
returns the evaluation
of object
after reactivating all inactive functions
in it.