Взаимодействия среды

eval чувствителен к значению переменной окружения LEVEL, который определяет максимальную глубину замены для идентификаторов.

Пример 1

subs выполняет замену, но не оценивает результат:

subs(ln(x), x = 1)

Явный вызов eval необходим, чтобы оценить результат:

eval(subs(ln(x), x = 1))

text2expr не оценивает свой результат также:

a := c:
text2expr("a + a"), eval(text2expr("a + a"))

Пример 2

Функциональный hold предотвращает оценку своего аргумента. Более поздняя оценка может быть обеспечена с eval:

hold(1 + 1);  eval(%)

Пример 3

Когда объект оценен, идентификаторы заменяются их значениями рекурсивно. Максимальная глубина рекурсии этого процесса дана переменной окружения LEVEL:

delete a0, a1, a2, a3, a4:
a0 := a1:  a1 := a2 + 2:  a2 := a3 + a4:  a3 := a4^2:  a4 := 5:

LEVEL := 1:  a0, a0 + a2;
LEVEL := 2:  a0, a0 + a2;
LEVEL := 3:  a0, a0 + a2;
LEVEL := 4:  a0, a0 + a2;
LEVEL := 5:  a0, a0 + a2;

eval сначала оценивает свой аргумент и затем оценивает результат снова. Обе оценки происходят с глубиной замены, данной LEVEL:

LEVEL := 1:  eval(a0, a0 + a2);
LEVEL := 2:  eval(a0, a0 + a2);
LEVEL := 3:  eval(a0, a0 + a2);

Поскольку значением по умолчанию LEVEL является 100, eval обычно не имеет никакого эффекта на интерактивном уровне:

delete LEVEL:
a0, eval(a0), a0 + a2, eval(a0 + a2)

Пример 4

Этот пример показывает различие между оценкой идентификаторов и локальными переменными. По умолчанию значением LEVEL является 1 в рамках процедуры, т.е. глобальный идентификатор заменяется его значением, когда оценено, но нет никакой дальнейшей рекурсивной оценки. Это изменяется, когда LEVEL присвоен большее значение в процедуре:

delete a0, a1, a2, a3:
a0 := a1 + a2:  a1 := a2 + a3:  a2 := a3^2 - 1:  a3 := 5:
p := proc() 
       save LEVEL; 
     begin
       print(a0, eval(a0)):
       LEVEL := 2:
       print(a0, eval(a0)):
     end_proc:

p()

Напротив, оценка локальной переменной заменяет его своим значением без дальнейшей оценки. Когда eval применяется к объекту, содержащему локальную переменную, затем эффект является оценкой значения локальной переменной с глубиной замены LEVEL:

q := proc()
       save LEVEL;
       local x;
     begin
       x := a0:
       print(x, eval(x)):
       LEVEL := 2:
       print(x, eval(x)):
     end_proc:
q()

Команда x:=a0 присваивает значение идентификатора a0, а именно, неоцененное выражение a1+a2, к локальной переменной x и x, заменяется этим значением каждый раз, когда это оценено, независимо от значения LEVEL:

Пример 5

В отличие от списков и наборов, оценка массива не оценивает свои записи. Таким образом eval не имеет никакого эффекта для массивов также. Используйте map, чтобы оценить все записи массива:

delete a, b:
L := [a, b]:  A := array(1..2, L):  a := 1:   b := 2:
L, A, eval(A), map(A, eval)

Вызов map(A, gamma) не оценивает записи массива A прежде, чем применить функциональный gamma. Сопоставьте функциональный gamma@eval, чтобы осуществить оценку:

map(A, gamma), map(A, gamma@eval)

Пример 6

Точно так же оценка таблицы не оценивает свои записи, и можно использовать map, чтобы достигнуть этого. Однако это не влияет на индексы:

delete a, b:
T := table(a = b):  a := 1:  b := 2:
T, eval(T), map(T, eval)

Если вы хотите таблицу с оцененными индексами также, составляете новую таблицу от оцененных операндов старой таблицы. Используя eval необходимо здесь начиная с функции операнда op не оценивает возвращенные операнды:

op(T), table(eval(op(T)))

Пример 7

Polynomials инертен, когда оценено, и также eval не имеет никакого эффекта:

delete a, x:  p := poly(a*x, [x]):  a := 2:  x := 3:
p, eval(p), map(p, eval)

Используйте mapcoeffs, чтобы оценить все коэффициенты:

mapcoeffs(p, eval)

Если вы хотите заменить значением неопределенный x, используйте evalp:

delete x:  evalp(p, x = 3)

Как вы видите, результат вызова evalp может содержать неоцененные идентификаторы, и можно оценить их приложением eval:

eval(evalp(p, x = 3))

Пример 8

Оценка элемента пользовательские области зависит от реализации области. Обычно, это не оценено далее:

delete a:  T := newDomain("T"):
e := new(T, a):  a := 1:
e, eval(e), map(e, eval), val(e)

Если слот "evaluate" существует, соответствующая стандартная программа слота называется для доменного элемента каждый раз, когда это оценено. Мы реализуем стандартный T::evaluate, который просто оценивает все внутренние операнды его аргумента для нашего доменного T. К неоцененному доменному элементу можно все еще получить доступ через val:

T::evaluate := x -> new(T, eval(extop(x))):
e, eval(e), map(e, eval), val(e)

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

Объект Evaluated.