`prog`::`trace`

Наблюдайте функции

Блокноты MuPAD® будут демонтированы в будущем релизе. Используйте live скрипты MATLAB® вместо этого.

Live скрипты MATLAB поддерживают большую часть функциональности MuPAD, хотя существуют некоторые различия. Для получения дополнительной информации смотрите, Преобразуют Notebook MuPAD в Live скрипты MATLAB.

Синтаксис

prog::trace(obj, <Recursive = FALSE>)
prog::trace({obj₁, obj₂, …}, <Recursive = FALSE>)
prog::trace(options)

Описание

prog::trace(obj) управляет объектом obj MuPAD^® наблюдать ввод и выход из этого объекта.

Примечание

prog::trace имеет новый синтаксис и новый набор опций. Старый синтаксис был удален.

prog::trace позволяет вам наблюдать функции, области, доменные методы и функциональные среды. Используйте prog::trace функция для отладки. Смотрите Пример 1.

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

prog::trace позволяет вам наблюдать отношения между вызовами прослеженных объектов.

Прослеживать объект obj, используйте вызов функции prog::trace(obj). После того вызова каждый раз вызов функции вводит или выходит из объекта obj, MuPAD распечатывает сообщение и возвращает аргументы и возвращаемое значение того вызова. Смотрите Пример 3.

prog::trace позволяет вам наблюдать область или функциональную среду. Когда вы вызываете prog::trace функция для области, функция наблюдает все методы области. Когда вы вызываете prog::trace для функциональной среды это наблюдает все пазы функциональной среды. Чтобы проследить только конкретные методы (пазы), обеспечьте набор этих методов (пазы). Смотрите slot страница справки для получения дополнительной информации. Смотрите Пример 8.

Чтобы предотвратить трассировку всех пазов функциональной среды, установите значение Recursive опция к FALSE. Смотрите пример 7.

Функциональный prog::untrace(obj) отключает трассировку объекта obj. Здесь obj функция, набор функций, области, доменного метода или функциональной среды. Функциональный prog::traced обнаруживает, прослеживает ли система в настоящее время конкретный объект.

Примеры

Пример 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():

Параметры

`obj`	Функция MuPAD, область, метод или функциональная среда, чтобы наблюдать. Задайте методы их `slot` имена (строки).
`_{{obj1, obj2, …}}`	Набор функций MuPAD, областей, методов или функциональных сред, чтобы наблюдать.

Опции

`Depth`	Опция, заданная как `Depth = level` Отобразите вызовы вложенной функции только до глубины рекурсии `level`. Здесь `level` положительное целое число. После того, как вы устанавливаете эту опцию, все новые и регенерированные выходные параметры для прослеженных объектов показывают, что вложенная функция вызывает только до заданной глубины рекурсии. Смотрите Пример 3.
`Mem`	Покажите текущее использование памяти. После того, как вы установите эту опцию, все новые и регенерированные выходные параметры для прослеженных объектов показывают информацию о текущем использовании памяти. Смотрите Пример 4.
`NoArgs`	Не показывайте аргументы вызовов прослеженных объектов и возвращенных значений. Без этой опции все выходные параметры для прослеженных объектов показывают аргументы и возвращенные значения для каждого вызова прослеженного объекта. Смотрите Пример 5.
`Parent`	Покажите имя процедуры, которая вызывает прослеженный объект. После того, как вы устанавливаете эту опцию, все новые и регенерированные выходные параметры для прослеженных объектов показывают имена процедур, которые вызывают прослеженные объекты. Смотрите Пример 6.
`Recursive`	Опция, заданная как `Recursive = FALSE` Не прослеживайте все пазы функциональной среды или области. По умолчанию, `Recursive = TRUE`. Смотрите пример 7.

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

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

Смотрите также

Функции MuPAD

debug | prog::profile | prog::traced | prog::untrace

Документация