Simplify

Упростите выражение

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

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

Синтаксис

Simplify(f)
Simplify(f, Steps = numberOfSteps)
Simplify(f, options)

Описание

Simplify(f) применяет переписывающие термин правила к f и возвращает самое простое выражение, которое это может найти.

Методы поиска самого простого представления выражения отличаются для Simplify и simplify. simplify функция выполняет линейный поиск, пытающийся улучшить результат, возвращенный предыдущим шагом упрощения. Simplify функционируйте использует результаты, возвращенные всеми предыдущими шагами упрощения (поиск по первому наилучшему совпадению). simplify функция быстрее. Simplify функция является медленнее, но более эффективной и более конфигурируемой.

Термин “самый простой” определяется следующим образом. Один объект более прост, чем другой, если он имеет меньшую оценку. Если два объекта имеют ту же оценку, Simplify выбирает более простой объект с помощью внутренней эвристики. Оценка является функцией, которая присваивает неотрицательный вещественный номер каждому объекту MuPAD^®. Заменять оценку по умолчанию, используемую Simplify, используйте Valuation опция. Simplify использует оценку в поиске по первому наилучшему совпадению что касается определения лучшего результата в последнем шаге. Однако можно задать отдельный метод для итогового шага упрощения при помощи Criterion опция.

Процесс упрощения состоит из шагов. На каждом шаге, Simplify выполняет один из следующих видов задач для a := f или некоторые (ранее полученный) объект a эквивалентный f. На каждом шаге, Simplify может произвести новые объекты, эквивалентные f (результаты) или новые задачи сделать или оба:

'InitialStep' : Найдите все правила для a. Simplify функция выполняет поиск всех правил для каждого нового объекта a. Этот поиск не приводит ни к какому новому результату.
Перезапись шага: Примените одно правило к a. Этот шаг может или привести к сбою или произвести эквивалентный объект как результат.
Шаг подвыражения: Выполните один шаг в упрощении операнда a. Замените операнд на возвращенный результат (если существуют какие-либо результаты). Этот шаг может произвести новый эквивалентный объект.

Каждая открытая задача имеет приоритет, который определяет, что сделать затем. Упрощение завершает работу в любом из следующих случаев:

Нет никаких более открытых задач.
Simplify достигнутый ограничение по времени задано Seconds.
Simplify выполняемый максимальное количество шагов упрощения задано Steps.
Simplify возвращенный объект задан Goal.

Simplify всегда возвращает “самый простой” эквивалентный объект, найденный на всех шагах упрощения, если вы не задаете другой OutputType.

Правила формируют конкретный доменный Rule. Они состоят из шаблона (левая сторона), выражение (правая сторона) и опции.

MuPAD организует правила для Simplify в основах правила. Можно изменить основу правила по умолчанию при помощи RuleBase опция. Также можно задать собственный механизм выбора правила при помощи SelectRules опция.

Как правило, Simplify применяет выбранные правила к данному объекту a в целом. Следующий случай является исключением из этого правила. Если шаблон правила и объекта a оба сумма или продукт, затем Simplify применяет правило к каждой подсумме или промежуточному результату a это имеет то же количество операндов как шаблон.

При помощи ApplyRule опция, можно задать собственную функцию, которая применяет конкретное правило к конкретному объекту. В противном случае, Simplify использует метод по умолчанию.

Приложение правила к объекту a сбои, если шаблон не соответствует (см. match) объект a. Производительность Simplify строго зависит от количества успешных соответствий. Поэтому, если вы задаете свою собственную основу правила, она должна избавиться от несоответствия с правилами перед выбором правила.

Шаг упрощения для операнда работает как шаг упрощения над упрощением f. Исключения следующие. Выполняя шаг упрощения для операнда, MuPAD не применяет определенные правила (см. детали о SelectRules).

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

Стратегия определяет приоритет правила. Смотрите Strategy опция для деталей.

Simplify никогда не использует симметрию математической эквивалентности выражений. Поэтому можно использовать Simplify как общая система перезаписи.

Simplify карты к спискам, наборам и таблицам.

Для доменных элементов dупрощение может быть перегружен двумя способами. Во-первых, Simplify использует паз d::dom::Simplify. Если тот паз не существует, Simplify использование d::dom::simplify. Если паз, что Simplify использование не является списком, Simplify вызывает паз и принимает результат как простой (даже если оценка не соглашается). В этом случае, Simplify не применяет никакие другие правила к d. Однако Simplify использует оценку, чтобы решить, должна ли она заменить доменный элемент, который происходит как операнд в другом объекте с его “упрощенной” версией. Если паз является списком, его записи должны быть правилами и Simplify применяет их согласно их приоритету.

Примеры

Пример 1

Самый легкий способ использовать Simplify должен принять все значения по умолчанию, и затем включить выражение, которое вы хотите упростить:

Simplify(sin(x)^2 + cos(x)^2)

Пример 2

По умолчанию, Simplify возвращает только одно выражение, которое функция рассматривает как самое простое. Чтобы возвратить список всех эквивалентных выражений, используйте All опция:

Simplify(sin(x)^2 + cos(x)^2, All)

Пример 3

Выход предыдущего примера короток потому что, как только simplifier находит 1, это сразу останавливается. После этого simplifier не ищет другие эквивалентные выражения. Кроме того, simplifier отбрасывает эквивалентные выражения, которые значительно более сложны, чем лучшее выражение, найденное ранее. Можно выключить оба механизма:

Simplify(sin(x)^2 + cos(x)^2, All, Discard = FALSE,
                                  IsSimple = FALSE)

Пример 4

По умолчанию, Simplify использует оценку, которая способствует выражениям с меньшим количеством различных иррациональных подвыражений. Например, Simplify принимает что выражение, содержащее только sin(x) или cos(x) более просто, чем выражение, содержащее обоих:

Simplify(cos(x)*sin(x))

Если вы берете length как мера по сложности для выражений, Simplify возвращает другой результат:

Simplify(cos(x)*sin(x), Valuation = length)

Пример 5

Количество по умолчанию шагов равняется 100. Чтобы изменить максимальное количество возможных шагов упрощения, используйте Steps опция. Например, уменьшение (приводящий к ускорению) и увеличение (приводящий к, вероятно, лучшему упрощению) количество шагов упрощения:

f := ln(x) + ln(3) - ln(3*x) + (exp(x) - 1)/(exp(x/2) + 1):
Simplify(f, Steps = 8), Simplify(f, Steps = 120)

delete f:

Пример 6

Для многих выражений количество по умолчанию шагов упрощения не позволяет simplifier находить хорошее упрощение:

Simplify(e^(a* x *(a + 1) + b2* y *(y + b2* x* y)))

Увеличение этого предела часто помогает:

Simplify(e^(a* x *(a + 1) + b2* y *(y + b2* x* y)), Steps=125)

Пример 7

По умолчанию функции упрощения не комбинируют логарифмы:

Simplify(ln(x^3 - 1) - ln(x - 1))

Используя IgnoreAnalyticConstraints опция, часто можно получать более короткие результаты:

Simplify(ln(x^3 - 1) - ln(x - 1), IgnoreAnalyticConstraints)

Пример 8

Можно написать то же выражение в различных системах координат. Например, используйте Декартовы и полярные координаты:

assume(x/r = cos(Symbol::theta)):
assumeAlso(y/r = sin(Symbol::theta)):
assumeAlso(r = sqrt(x^2+y^2)):
x/sqrt(x^2+y^2) + I*y/sqrt(x^2+y^2) = exp(I*Symbol::theta);
Simplify(%)

Пример 9

Следующее выражение эквивалентно exp(x):

a := -1/(sin(1/2*I*x)^2 + 4*sin(1/4*I*x)^4 -
     4*sin(1/4*I*x)^2 + 1)*(sin(1/2*I*x)^2 -
     4*I*sin(1/2*I*x)*sin(1/4*I*x)^2 + 2*I*sin(1/2*I*x) - 
     4*sin(1/4*I*x)^4 + 4*sin(1/4*I*x)^2 - 1)

Simplify распознает эквивалентность a и exp(x) в 100 шагах. Чтобы показать, как функция доказывает эквивалентность на каждом шаге, используйте OutputType опция. Обратите внимание на то, что доказательство, возвращенное Simplify не доказательство в строгом математическом смысле. Simplify использует правила от основы правила по умолчанию:

Simplify(a, OutputType = "Proof")

Input was
  -(sin((x*I)/2)^2 - 4*sin((x*I)/2)*sin((x*I)/4)^2*I + 2*sin((x*I)/2)*I - \
4*sin((x*I)/4)^4 + 4*sin((x*I)/4)^2 - 1)/(sin((x*I)/2)^2 + 4*sin((x*I)/4)^\
4 - 4*sin((x*I)/4)^2 + 1)
Applying the rule
  Simplify::combineSinCos
gives
  cos(x*I) - sin(x*I)*I
Applying the rule
  Simplify::expand
gives
  cosh(x) + sinh(x)
Applying the rule
  X -> rewrite(X, exp)
gives
  exp(x)
END OF PROOF

Пример 10

Также можно использовать Simplify для экспериментов с формальными грамматиками, данными только несколькими правилами. В этом случае лучший подход не должен использовать основы правила, но использовать SelectRules метод, который возвращает список всех правил. Следующий пример представляет общий ассоциативный оператор ?. Пример вычисляет количество всех возможных размещений круглых скобок. Во-первых, задайте operator, и затем присоедините его к функции, которая управляет ее выходом (см. funcenv). Укажите, что единственное применимое правило является ассоциативным законом. В вызове Simplify, определите номер шагов к очень большому значению, чтобы выполнить полный поиск. Обратите внимание на то, что большинство грамматик производит бесконечно много слов и проводит бесконечное время, чтобы закончить полный поиск:

_f := funcenv(() -> procname(args())):
operator("?", _f, Binary, 1000):
R := Rule((X ? Y) ? Z, X ? (Y ? Z)):
selectProc := () -> [R]:
S := Simplify(u ? v ? x ? y ? z, Steps = 10^10,
              SelectRules = selectProc, All):

PRETTYPRINT := FALSE:
print(Plain, S):
PRETTYPRINT := TRUE:

[u ? (v ? (x ? (y ? z))), u ? (v ? ((x ? y) ? z)), u ? ((v ? (x ? y)) ? z)\
, u ? (((v ? x) ? y) ? z), u ? ((v ? x) ? (y ? z)), (u ? (v ? x)) ? (y ? z\
), ((u ? v) ? x) ? (y ? z), (u ? v) ? (x ? (y ? z)), (u ? v) ? ((x ? y) ? \
z), (u ? (v ? (x ? y))) ? z, (u ? ((v ? x) ? y)) ? z, ((u ? (v ? x)) ? y) \
? z, (((u ? v) ? x) ? y) ? z, ((u ? v) ? (x ? y)) ? z]

Существует 14 возможных способов поместить круглые скобки:

nops(S); 
delete fout, _f, R, S, selectProc:
operator("?", Delete):

Пример 11

Если вы хотите задать больший ряд правил, лучший подход должен использовать вашу собственную основу правила. Классическим примером является дифференцирование. Несмотря на то, что эвристический поиск должен быть медленнее, чем простой рекурсивный алгоритм, этот пример подходит для демонстрации некоторых факторов КПД. Запустите путем определения функциональной среды mydiff это ничего не делает:

mydiff := funcenv(mydiff):
mydiff::type := "mydiff"

Цель этого определения состоит в том, чтобы показать, что виды MuPAD управляют в основах правила типами выражений, к которым MuPAD применяет те правила. Поэтому mydiff получает его собственный тип. Теперь задайте основу правила Myrules с обычными правилами дифференцирования. Не используйте дополнительные правила:

Myrules := newDomain("Myrules"):
Myrules::mydiff :=
     [Rule(mydiff(f, x), 0, {(f, x) -> not has(f, x)}),
      Rule(mydiff(x, x), 1),
      Rule(mydiff(x^n, x), n*x^(n - 1)),
      Rule(mydiff(f*g, x), f*mydiff(g, x) + g*mydiff(f, x)),
      Rule(mydiff(f + g, x), mydiff(f, x) + mydiff(g, x))
     ]:

Эта основа правила работает на выражение x ²:

Simplify(mydiff(x^2, x), RuleBase = Myrules)

Однако основа правила не работает на следующее выражение:

Simplify(mydiff(x + 3, x), RuleBase = Myrules)

Попытайтесь улучшить ту основу правила. Как первый шаг, увеличьте число шагов упрощения. Увеличение числа шагов не помогает в этом случае:

Simplify(mydiff(x + 3, x), RuleBase = Myrules, Steps = 200)

Как второй шаг, более тщательно изучите по эквивалентным выражениям, возвращенным Simplify. Иногда, Simplify находит ожидаемый результат, но не возвращает его, потому что оценка ожидаемого результата выше, чем оценка некоторого другого эквивалентного выражения. Для выражения x + 3, Simplify функция не находит ожидаемый результат:

l := Simplify(mydiff(x + 3, x), RuleBase = Myrules, All)

Обратите внимание на то, что производная 1 появляется в результате. Используйте OutputType опция, чтобы проверять, как Simplify управляет третьим сроком l[3] и как это доказывает эквивалентность ввода и вывода на каждом шаге:

Simplify(mydiff(x + 3, x), RuleBase = Myrules, 
                           Goal = l[3],
                           OutputType = "Proof")

Input was
  mydiff(x + 3, x)
Applying the rule
  mydiff(f*g, x) -> f*mydiff(g, x) + g*mydiff(f, x)
gives
  (x + 3)*mydiff(1, x) + mydiff(x + 3, x)
END OF PROOF

Теперь вы видите, что для каждого выражения f, необходимо задать правило для diffentiating продуктов потому что f = 1 f. Измените то правило:

(Myrules::mydiff)[4] := Rule(mydiff(f*g, x), 
                             f*mydiff(g, x) + g*mydiff(f, x),
                             {(f, g) -> f <> 1 and g <> 1}):

Обновленная основа правила работает:

Simplify(mydiff(x + 3, x), RuleBase=Myrules, Remember=FALSE)

Используйте несколько опций, чтобы оптимизировать вызов Simplify. Как первый шаг, измерьтесь, сколько шагов типичный пример делает прежде, чем возвратить ожидаемый выходной параметр:

Simplify(mydiff(5*x^4 + x^3 + x^2 + x + 1, x),
         RuleBase = Myrules, 
         Steps = 2000, 
         Goal = 20*x^3 + 3*x^2 + 2*x + 1, 
         OutputType = "NumberOfSteps")

Избегайте приложения равенства f = f + 0. Выключите помнить механизм. Когда помнить механизм работает, Simplify игнорирует изменения в основе правила:

Myrules::mydiff[5] := Rule(mydiff(f + g, x), 
                           mydiff(f, x) + mydiff(g, x),
                           {(f, g) -> f <> 0 and g <> 0}):
Simplify(mydiff(5*x^4 + x^3 + x^2 + x + 1, x), 
         RuleBase = Myrules, 
         Steps = 2000, 
         Goal = 20*x^3 + 3*x^2 + 2*x + 1, 
         OutputType = "NumberOfSteps", 
         Remember = FALSE)

Затем попытайтесь изменить критерии оценки. Например, используйте length:

Simplify(mydiff(5*x^4 + x^3 + x^2 + x + 1, x),
         RuleBase = Myrules, 
         Steps = 2000, 
         Goal = 20*x^3 + 3*x^2 + 2*x + 1, 
         OutputType = "NumberOfSteps", 
         Valuation = length)

Оптимизировать вызов Simplify, также можно задать собственную стратегию упрощения. Например, первое правило, кажется, обеспечивает очень полезное упрощение каждый раз, когда оно применяется. Поэтому присвойте высокий приоритет этому правилу путем предположения, что в среднем это правило упрощает свой вход до 0.03 из исходной сложности:

Myrules::mydiff[1] := subsop(Myrules::mydiff[1],
                             4 = table("MyStrategy" = 0.03)):
Simplify(mydiff(5*x^4 + x^3 + x^2 + x + 1, x),
         RuleBase = Myrules, 
         Steps = 3000, 
         Goal = 20*x^3 + 3*x^2 + 2*x + 1, 
         OutputType = "NumberOfSteps", 
         Strategy = "MyStrategy")

При использовании оценки length, вы получаете следующий результат:

Simplify(mydiff(5*x^4 + x^3 + x^2 + x + 1, x), 
         RuleBase = Myrules, 
         Steps = 3000, 
         Goal = 20*x^3 + 3*x^2 + 2*x + 1, 
         OutputType = "NumberOfSteps", 
         Strategy = "MyStrategy", 
         Valuation = length)

Когда вы используете находящееся в matcher упрощение, большинство правил не соответствует к большинству объектов. Попытка совпадать со всеми правилами ко всем объектам производит много шагов перезаписи сбоя. Рекомендуемый подход должен отбросить эти провальные правила во время начального шага. Отбрасывание провальных правил сокращает число шагов. Это также увеличивает время выполнения на шаг небольшим количеством. Определение процедуры вместо списка правил может помочь вам отбросить провальные правила во время начального шага. Можно задать правила при помощи шаблона или процедуру в качестве их первого аргумента:

Myrules::mydiff := 
proc(df) 
  begin 
  [if not has(op(df, 1), op(df, 2)) then 
      Rule(X -> 0) 
   else
      case type(op(df, 1)) 
        of "_plus" do 
           Rule(X -> map(op(X, 1), mydiff, op(X, 2)));
           break
        of "_mult" do
           Rule(mydiff(f*g, x), f*mydiff(g, x) + g*mydiff(f, x));
           break
        of "_power" do
           Rule(X -> op(X, [1,2])*op(X, [1,1])^(op(X, [1,2]) - 1));
           break
        of DOM_IDENT do
           assert(op(df, 1) = op(df, 2));
           Rule(X -> 1);
           break
        otherwise
           null()
       end_case
    end_if]
end_proc:
Simplify(mydiff(5*x^4 + x^3 + x^2 + x + 1, x), 
         RuleBase = Myrules, 
         Steps = 200, 
         Goal = 20*x^3 + 3*x^2 + 2*x + 1, 
         OutputType = "NumberOfSteps")

delete Myrules, mydiff:

Параметры

`f`	Любой объект

Опции

`All`	Когда вы используете `All` опция, `Simplify` функция возвращает список всех эквивалентных объектов, которые может найти функция. Этот синтаксис является ярлыком для `OutputType = "All"`.
`ApplyRule`	Опция, заданная как `ApplyRule = applyFunction` Задайте функциональный `applyFunction` тот `Simplify` вызывает каждый раз когда правило `R` должен быть применен к объекту `a`. Здесь, `applyFunction` должна быть функция двух аргументов `R` (правило) и `a` (объект). Это должно возвратить результат применения правила `R` к объекту `a`. Если правило не применимо, `applyFunction` функция должна возвратить `FAIL`.
`Discard`	Опция, заданная как `Discard = discardFunction` Задайте функциональный `discardFunction(newvalue, bestvalue)` тот `Simplify` вызывает каждый раз, когда это находит новый объектный эквивалент `f`. Здесь `newvalue` оценка нового объекта и `bestvalue` минимальная оценка среди всех эквивалентных объектов что `Simplify` найденный ранее. Если булева оценка результата производит `TRUE`, затем `Simplify` отбрасывает новый объект. По умолчанию, `Simplify` отбрасывает результат, если его оценка превышает `10×current best valuation + 1`. Чтобы предотвратить потерю результатов, выключите этот механизм: `Discard = FALSE`.
`Criterion`	Опция, заданная как `Criterion = CriterionFunction` Задайте функциональный `CriterionFunction(a, vala)` тот `Simplify` вызовы в конце расчета, чтобы выполнить итоговую сортировку результатов. Для каждого результата `a` и его оценка `vala`, `CriterionFunction(a, vala)` возвращает номер. `Simplify` использование, что номер, чтобы отсортировать результаты. По умолчанию, `Simplify` использование `vala` отсортировать результаты.
`Goal`	Опция, заданная как `Goal = a` Если `Simplify` функция находит эквивалентный объект `a`, остановите расчет и возвратите `a` даже если этот объект не является самым простым эквивалентным найденным выражением.
`IgnoreAnalyticConstraints`	При использовании этой опции simplifier применяет следующие правила к выражениям: ln (a) + ln (b) = ln (a b) для всех значений a и b. В частности: для всех значений a, b и c ln (a ^b) = b ln (a) для всех значений a и b. В частности: для всех значений a, b и c Если f и g являются стандартными математическими функциями и f (g (x)) = x для всех маленьких положительных чисел, f (g (x)) =, x принят, чтобы быть допустимым для всего комплексного x. В частности: arcsin (sin (x)) = x, arccos (cos (x)) = x, arctan (tan (x)) = x arcsinh (sinh (x)) = x, arccosh (cosh (x)) = x, arctanh (tanh (x)) = x для всех значений k При использовании этой опции, `Simplify` функция может возвратить простые результаты для выражений для который `Simplify` без этой опции возвращает более сложные результаты. При использовании этой опции simplifier не гарантирует равенства начального выражения и результата для всех символьных параметров. Смотрите Пример 7.
`IsSimple`	Опция, заданная как `IsSimple = B` Задайте функциональный `B(a)` то, что `Simplify` вызовы функции для любого выражения `a` это эквивалентно любому подвыражению входа. Если результатом вызова является `TRUE`, затем `Simplify` функция не упрощает это подвыражение дальше. `B` должен возвратить `TRUE` или `FALSE` для каждого входа.
`KernelSteps`	Опция, заданная как `KernelSteps = n` Ограничьте усилие, которое инвестируют в один шаг упрощения. Здесь `n` должно быть положительное целое число. Значение по умолчанию равняется 100.
`OutputType`	Опция, заданная как `OutputType = output` Задайте тип возвращаемого значения. Значение `output` должна быть одна из строк `"All"`, `"Best"`, `"NumberOfSteps"`, или `"Proof"`. Эта опция делает `Simplify` возвратите все результаты, лучший результат, количество выполняемых шагов упрощения или доказательство для эквивалентности входа и лучшего результата. По умолчанию, `Simplify` возвращает самый простой найденный результат. Даже если вы указываете, что выход вводит как `"All"упрощение` не возвращает результатов, отброшенных из-за `Discard` опция. Чтобы получить все результаты, установите `Discard` к `FALSE`. Смотрите пример 3. Если вы устанавливаете эту опцию на `"Proof"`, `Simplify` функция возвращает текст, отображающий шаги доказательства и леммы. Шаги доказательства утверждают, что f_{, i - 1} эквивалентен f _i для 1 ≤ i ≤ n, где f ₀ = f является входом и f _n, является результатом упрощения. Каждый шаг доказательства является или приложением правила или приложением леммы. Шаг приложения правила показывает, что, применяя правило к f _{i - 1} дает f _i. Шаги приложения леммы показывают, что заменяющий некоторый операнд f _{i - 1} эквивалентным объектом дает f _i. Лемма состоит из оператора, что два объекта эквивалентны, доказательство в вышеупомянутом смысле и `END OF LEMMA` тег. Технически, доказательствами являются объекты того же типа как выход `expose`.
`Remember`	Опция, заданная как `Remember = bool` `Remember` опция переключает помнить механизм на и прочь. Если вы вызываете `Simplify` с тем же аргументом несколько раз, помнить механизм экономит время выполнения. Если аргумент одного вызова вновь появляется как подвыражение в аргументе другого вызова, помнить механизм не помогает сэкономить время. По умолчанию, `bool` `TRUE`.
`RuleBase`	Опция, заданная как `RuleBase = base` Основа правила `base` область, которая содержит ее правила для выражений типа `T` в его пазе `slot(base, T)`. Кроме того, следующие три паза могут содержать правила для основы правила: `base::All`, `base::Global`, и `base::Local`. `base::All` паз содержит обычно применимые правила. `base::Global` паз содержит правила что `Simplify` функция применяется только к выражениям. `Simplify` не применяет правила, заданные в `base::Global` в шаге подвыражения. `base::Local` паз содержит правила что `Simplify` функция применяется только в шаге подвыражения. Если никакие пазы не существуют для типа данного объекта, MuPAD не генерирует правил для того объекта. Паз основы правила является списком правил или процедуры, которая возвращает такой список для любого данного объекта соответствующего типа. Любое правило должно быть объектом типа `Rule`. Смотрите `Rule` страница справки для деталей. Если вы используете свой собственный `SelectRules`, можно проигнорировать эти соглашения. Смотрите Пример 11.
`Seconds`	Опция, заданная как `Seconds = t` Когда вы используете `Seconds` опция, `Simplify` функционируйте ограничивает время, допускал внутренний процесс упрощения. Значение `t` максимальное время в секундах. По умолчанию процесс упрощения никогда не завершает работу из-за ограничения времени: `t = infinity`.
`SelectRules`	Опция, заданная как `SelectRules = selFunction` Когда вы используете `SelectRules` опция, MuPAD позволяет вам задать функциональный `selFunction(base, ex, global, strat)` тот `Simplify` вызовы, чтобы получить правила, применимые к `ex` в правиле основывают `base` для стратегии `strat`. Булев флаг `global` указывает ли `ex` целое выражение, принятое `Simplify` (`global = TRUE`) или подвыражение исходного выражения (`global = FALSE`). Используя аргументы, данные `selFunction` является дополнительным. Например, для маленького правила базируется, самый легкий метод должен возвратить список всех правил, независимых от данного выражения. Смотрите Пример 10. Однако возврат списка всех правил может привести к ненужным приложениям правила. Применение каждого ненужного правила возвращает `FAIL` и только влияет на производительность. Можно задать любую основу правила и использовать любой вид правила. Единственным ограничением является тот `selFunction` должен возвратить список правил.
`Steps`	Опция, заданная как `Steps = numberOfSteps` Когда вы используете `Steps` опция, `Simplify` функция отключает упрощение после `numberOfSteps` шаги упрощения. Количество по умолчанию шагов равняется 100.
`StopIf`	Опция, заданная как `StopIf = B` Когда вы используете `StopIf` опция, `Simplify` функция позволяет вам задать функциональный `B(a)` тот `Simplify` призывы к любому выражению `a` это эквивалентно исходному выражению. Если результатом является `TRUE`, упрощение сразу останавливается, и `Simplify` функция возвращает выражение `a` как самый простой результат независимо от его оценки. Заданный функциональный `B` должен возвратить `TRUE` или `FALSE` для любого входа.
`Strategy`	Опция, заданная как `Strategy = strat` Когда вы используете `Strategy` опция, `Simplify` функция позволяет вам установить стратегию выбора правила. Значение `strat` должна быть строка. `SelectRules` опция использует `strat` в качестве аргумента, который определяет приоритет для применения каждого правила. По умолчанию, `Simplify` использует стратегию `"Default"`. Основа правила по умолчанию также использует стратегию `"Default"`. Если конкретное правило не распознает стратегию `strat`, `Simplify` функционируйте использует стратегию `"Default"` определить приоритет того правила. Наконец, если никакая запись для стратегии по умолчанию не доступна, правило имеет приоритет 1. В этом случае ожидайте, что выход будет столь же сложным как вход. Если вы используете `IgnoreAnalyticConstraintsупрощение` использует стратегию, которая идет с той опцией вместо того, чтобы использовать стратегию `"Default"`. Если `Simplify` использует стратегию, та стратегия не влияет на оценку результатов приложений правила.
`Valuation`	Опция, заданная как `Valuation = valFunction` Когда вы используете `Strategy` опция, `Simplify` функция позволяет вам задать функциональный MuPAD использование для вычислительных оценок возвращенных объектов. `Simplify` вычисляет оценку для многих промежуточных результатов. Обычно вычислить оценку, `Simplify` оценивает каждый узел дерева выражений. Поэтому `Valuation` опция может значительно влиять на время выполнения. Хорошая оценка является компромиссом между концепциями максимального типа и контекстно-свободным. Для контекстно-свободной оценки и оператор выражения и оценки операндов определяют оценку выражения. Для оценки максимального типа обычно оценка выражения равняется максимуму оценок его операндов. Типичным контекстно-свободным примером является `length`. Типичным примером максимального типа является `X -> 2^nops(indets(X))` . MuPAD предлагает контекстно-свободной оценке `Simplify::complexity`. Эта оценка способствует обычным операторам как `exp` по необычным единицам как `besselJ` и помещает фактор штрафа на аргументы необычных операторов.

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

Simplify возвращает объект, математически эквивалентный входу. С опцией OutputType = "All", Simplify функция возвращает список всех эквивалентных объектов, найденных во время упрощения. С опцией OutputType = "NumberOfSteps", функция возвращает положительное целое число. С опцией OutputType = "Proof", функция возвращает строку, содержащую доказательство эквивалентности входа и результата.

Перегруженный

f

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

Функции MuPAD

collect | combine | expand | factor | match | normal | radsimp | rectform | rewrite | simplify

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