Упрощение

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

Блокноты 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 может быть перегружен двумя способами. Во-первых, 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"`, `Simplify` не возвращает результатов, отброшенных из-за опции `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`, `Simplify` использует стратегию, которая идет с той опцией вместо того, чтобы использовать стратегию `"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

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