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

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 100eval обычно не оказывает влияния на интерактивном уровне:

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.