Пример 1

Задайте функциональный f, и наблюдайте эту функцию:

f := x -> if x > 0 then x else -f(-x) end:
prog::trace(f):
f(-2)

enter f(-2)
  enter f(2)
  computed 2
computed -2

Измените функцию и повторно присвойте новую функцию f. Несмотря на то, что вы используете то же имя функции (f), MuPAD не прослеживает новую функцию:

f := x -> if x > 0 then x else f(-x) end:
f(-2)

Чтобы проследить новую функцию, вызовите prog::trace снова. Теперь механизм трассировки наблюдает обновленную функцию:

prog::trace(f):
f(-2)

enter f(-2)
  enter f(2)
  computed 2
computed 2

Для дальнейших расчетов остановите наблюдение за функцией:

prog::untrace(f)

Пример 2

Если вы хотите проследить больше чем одну функцию, используйте набор, чтобы задать эти функции в одном вызове функции:

prog::trace({sin, cos, exp}):
sin(5*PI/2);
cos(5*PI);
exp(5)

enter sin((5*PI)/2)
  enter sin(PI/2)
  remembered 1
computed 1

enter cos(5*PI)
  enter cos(PI)
  remembered -1
computed -1

enter exp(5)
computed exp(5)

Чтобы остановить наблюдение за всеми функциями, используйте prog::untrace без аргументов:

prog::untrace()

Пример 3

Задайте короткую функцию, которая вызывает себя рекурсивно, и наблюдайте вызовы:

fib:= proc(n)
      begin
        if n < 2 then
          n
        else
          fib(n - 1) + fib(n - 2)
        end_if
      end_proc:
prog::trace(fib):
fib(3)

enter fib(3)
  enter fib(2)
    enter fib(1)
    computed 1
    enter fib(0)
    computed 0
  computed 1
  enter fib(1)
  computed 1
computed 2

Ограничить количество вызовов вложенной функции, отображенных prog::trace, используйте Depth опция. Задавать значение Depth, используйте отдельный prog::trace вызов функции:

prog::trace(fib):
prog::trace(Depth = 2);
fib(12)

enter fib(12)
  enter fib(11)
  computed 89
  enter fib(10)
  computed 55
computed 144

Depth опция независима от fib процедура. Теперь, если вы используете prog::trace прослеживать любую другую процедуру, prog::trace отображает вложенные вызовы той процедуры с помощью Depth = 2. Удалите эту глобальную опцию для дальнейших расчетов:

prog::untrace(fib):
prog::trace(Depth = 0)

Пример 4

Чтобы отобразить использование памяти, используйте Mem опция:

prog::trace(Mem):
prog::trace(sin):
sin(3/2*PI)

enter
remember::sin((3*PI)/2) [mem: 3267052]   enter remember::sin(PI/2)
[mem: 4033596]   remembered 1 [mem: 4033436] computed -1 [mem: 4033072]
   -1 

Mem опция независима от прослеженной процедуры. Теперь, если вы используете prog::trace прослеживать любую другую процедуру, prog::trace использование памяти отображений на каждом шаге той процедуры. Удалите эту глобальную опцию для дальнейших расчетов::

prog::untrace(sin):
prog::trace(Mem = FALSE)

Пример 5

NoArgs опция подавляет выход аргументов прослеженных объектов:

prog::trace(linalg):
prog::trace(NoArgs);
linalg::eigenvalues(matrix([[1,  0, 0],
                            [0, -1, 2],
                            [0,  1, 1]]))

enter linalg::eigenvalues
  enter linalg::checkForFloats
  return
  enter linalg::charpoly
    enter linalg::charpolyBerkowitz
    return
  return
return

NoArgs опция независима от прослеженной процедуры. Теперь, если вы используете prog::trace прослеживать любую другую процедуру, prog::trace скрывает аргументы на каждом шаге той процедуры. Удалите эту глобальную опцию для дальнейших расчетов:

prog::untrace(linalg):
prog::trace(NoArgs = FALSE)

Пример 6

Если вы используете Parent опция, prog::trace показывает имя процедуры, которая вызывает прослеженный объект:

prog::trace(cos):
prog::trace(Parent):
f := x -> cos(2*x):
g := (x, y) -> f(x) + f(y):
g(3/2*PI, -3/2*PI)

enter cos(3*PI) (called from f)
  enter cos(PI) (called from cos)
  remembered -1
computed -1
enter cos(-3*PI) (called from f)
  enter cos(3*PI) (called from cos)
  remembered -1
computed -1

prog::trace(f):
prog::trace(g):
g(-PI, PI)

enter g(-PI, PI)
  enter f(-PI) (called from g)
    enter cos(-2*PI) (called from f)
      enter cos(2*PI) (called from cos)
        enter cos(0) (called from cos)
        remembered 1
      computed 1
    computed 1
  computed 1
  enter f(PI) (called from g)
    enter cos(2*PI) (called from f)
    remembered 1
  computed 1
computed 2

Parent опция независима от прослеженных процедур. Теперь, если вы используете prog::trace прослеживать любой другой объект, prog::trace показывает отношения между вызовами прослеженных объектов. Удалите эту глобальную опцию для дальнейших расчетов:

prog::untrace(cos):
prog::trace(Parent = FALSE)

Пример 7

По умолчанию, prog::trace функционируйте прослеживает все пазы функциональной среды. Например, проследите besselJ функционируйте и наблюдайте следующий вызов функции:

prog::trace(besselJ);
besselJ(1, 2.3)

enter besselJ(1, 2.3)
  enter besselJ::float(1, 2.3)
  computed 0.5398725326
computed 0.5398725326

Чтобы не использовать трассировку всех пазов, установите значение Recursive опция к FALSE:

prog::untrace(besselJ);
prog::trace(besselJ, Recursive=FALSE);
besselJ(1, 4.5)

enter besselJ(1, 4.5)
computed -0.2310604319

Для дальнейших расчетов остановите наблюдение за besselJ функция:

prog::untrace(besselJ)

Пример 8

Можно проследить области и доменные методы. Например, создайте следующую маленькую область:

T := newDomain("T"):
T::new := proc(h, m = 0) name T; begin new(T, h*60 + m) end:
T::intern := x -> [op(x) div 60, op(x) mod 60]:
T::print := x -> expr2text(T::intern(x)[1]).":".
                 substring(expr2text(100 + T::intern(x)[2]), 2, 2):
T::_plus := () -> new(T, _plus(map(args(), op))):
T::expr := op:
T::_mult := () -> new(T, _mult(map(args(), expr))):
prog::trace(T):
T(1, 30) + T(0, 45)*T(1, 05)

enter T(1, 30)
computed 1:30
enter T(0, 45)
computed 0:45
enter T(1, 5)
computed 1:05
enter T::_mult(0:45, 1:05)
computed 48:45
enter T::_plus(1:30, 48:45)
computed 50:15

MuPAD не прослеживает процесс отображения прослеженных выводов. Поэтому T::intern и T::print методы не появляются в прослеженных выходных параметрах.

Теперь проследите арифметические методы только. При определении методов, чтобы проследить, используйте их имена паза, такие как slot(T, "_plus") или T::_plus:

prog::untrace():
prog::trace({T::_plus, T::_mult}):
T(1, 30) + T(0, 45)*T(1, 05)

enter T::_mult(0:45, 1:05)
computed 48:45
enter T::_plus(1:30, 48:45)
computed 50:15

prog::untrace():

Возвращаемые значения

prog::trace возвращает пустой объект null().