expand
Расширьте выражение
Блокноты MuPAD® будут демонтированы в будущем релизе. Используйте live скрипты MATLAB® вместо этого.
Live скрипты MATLAB поддерживают большую часть функциональности MuPAD, хотя существуют некоторые различия. Для получения дополнительной информации смотрите, Преобразуют Notebook MuPAD в Live скрипты MATLAB.
expand(f
,options
) expand(f, g1, g2, …
,options
)
expand(f)
расширяет арифметическое выражение f
.
Самое важное использование expand
приложение закона о дистрибутивности, чтобы переписать продукты сумм как суммы продуктов. В этом отношении, expand
обратная функция factor
.
Числитель части расширен, и затем часть переписана как сумма частей с более простыми числителями; смотрите Пример 1. В некотором смысле это - обратная функциональность normal
. Используйте partfrac
для более мощного способа переписать часть как сумму более простых частей.
expand(f)
применяет следующие правила при перезаписи степеней, происходящих как подвыражения в f
:
x a + b = x a xb.
Если b
целое число или x ≥ 0 или y ≥ 0, затем (x y) b = x b yb.
Если b
целое число, затем (x a) b = x a b.
За исключением третьего правила, этого поведения expand
обратная функциональность combine
. Смотрите пример 2.
expand
работает рекурсивно над подвыражениями выражения f
. Если f
имеет контейнерный тип array
или table
расширение
только возвращает f
и не сопоставляет на записях. Чтобы расширить все записи одного из контейнеров, используйте map
. Смотрите пример 3.
Если дополнительные аргументы g1, g2, ...
присутствуют, затем любое подвыражение f
это равно одному из этих дополнительных аргументов, не расширен; смотрите Пример 4. Смотрите раздел “Background” для описания, как это работает.
Свойства идентификаторов учтены (см. assume
). Идентификаторы без любых свойств приняты, чтобы быть комплексными. Смотрите Пример 9.
expand
также различные типы указателей специальных математических функций. Это переписывает один вызов специальной функции со сложным аргументом как сумма или продукт нескольких вызовов той же функции или связанных функций с более простыми аргументами. В этом отношении, expand
обратная функция combine
.
В частности, expand
реализует функциональные уравнения показательной функции и логарифма, гамма функции и полигамма функции и теорем сложения для тригонометрических функций и гиперболических функций. Смотрите Пример 10.
expand
расширяет продукты сумм путем умножения:
expand((x + 1)*(y + z)^2)
После расширения числителя часть переписана как сумма частей:
expand((x + 1)^2*y/(y + z)^2)
Степень с суммой в экспоненте переписана как продукт степеней:
expand(x^(y + z + 2))
expand
работает рекурсивным способом. В следующем примере степень (x + y) z + 2 сначала расширен в продукт двух степеней. Затем степень (x + y) 2 расширена в сумму. Наконец, продукт последней суммы и остающейся степени (x + y) z умножается:
expand((x + y)^(z + 2))
Вот другой пример:
expand(2^((x + y)^2))
expand
карты на записях списков, наборов и матриц:
expand([(a + b)^2, (a - b)^2]); expand({(a + b)^2, (a - b)^2}); expand(matrix([[(a + b)^2, 0],[0, (a - b)^2]]))
expand
не сопоставляет на записях таблиц или массивов:
expand(table((a + b)^2=(c + 1)^2)), expand(array(1..1, [(a + b)^2]))
Используйте map
для того, чтобы расширить все записи контейнера:
map(table((a + b)^2=(c + 1)^2), expand), map(array(1..1, [(a + b)^2]), expand)
Обратите внимание на то, что этот вызов расширяет только записи в таблице, не ключи. В (редком) случае, что вы хотите ключи, расширенные также, преобразуйте таблицу к списку или системе уравнений сначала:
T := table((a + b)^2=(c + 1)^2): table(expand([op(T)]))
Если дополнительные аргументы обеспечиваются, expand
выполняет только частичное расширение. Эти дополнительные выражения, такие как x + 1
в следующем примере, не расширены:
expand((x + 1)*(y + z))
expand((x + 1)*(y + z), x + 1)
По умолчанию, expand
работает над всеми подвыражениями включая тригонометрические подвыражения:
e := (sin(2*x) + 1)*(1 - cos(2*x)): expand(e)
Чтобы предотвратить расширение подвыражений, используйте ArithmeticOnly
опция:
expand(e, ArithmeticOnly)
Опция не предотвращает расширение степеней и корней:
expand((sin(2*x) + 1)^3, ArithmeticOnly)
Чтобы сохранить подвыражения с целочисленными степенями нерасширенными, используйте MaxExponent
опция.
IgnoreAnalyticConstraints
опция применяет набор чисто алгебраических упрощений включая равенство суммы логарифмов и логарифма продукта. Используя IgnoreAnalyticConstraints
опция, вы получаете более простой результат, но тот, который может быть неправильным для некоторых значений переменных:
expand(ln(a*b*c*d), IgnoreAnalyticConstraints)
Не используя эту опцию, вы получаете математически правильный результат:
expand(ln(a*b*c*d))
Если дополнительный MaxExponent
если, expand
выполняет только частичное расширение. Полномочия с целочисленной экспонентой, больше, чем связанный данный, не расширены:
expand((a + b)^3, MaxExponent = 2)
Если экспонента меньше, или равняйтесь связанному данному, степень расширена:
expand((a + b)^2, MaxExponent = 2)
expand
функция может принять несколько опций одновременно. Предположим, что вы хотите расширить следующее выражение:
e := (sin(2*x) + 1)*(x + 1)^3
expand
без любых опций работает рекурсивно. Функция расширяет все подвыражения включая тригонометрические функции и степени:
expand(e)
ArithmeticOnly
опция предотвращает расширение термина sin(2x)
. MaxExponent
опция предотвращает расширение (x + 1) 3:
expand(e, ArithmeticOnly); expand(e, MaxExponent = 2)
Объединение этих опций в одном вызове expand
функция, вы вводите оба ограничения для расширения:
expand(e, MaxExponent = 2, ArithmeticOnly)
Следующие расширения не допустимы для всех значений a
B
от комплексной плоскости. Therefore, MuPAD® не расширяет эти выражения:
expand(ln(a^2)), expand(ln(a*b)), expand((a*b)^n)
Расширения допустимы под предположением что a
положительное вещественное число:
assume(a > 0): expand(ln(a^2)), expand(ln(a*b)), expand((a*b)^n)
Очистите предположение для дальнейших расчетов:
unassume(a):
В качестве альтернативы, чтобы получить расширенный результат для третьего выражения, примите тот n
целое число:
expand((a*b)^n) assuming n in Z_
Используйте IgnoreAnalyticConstraints
опция, чтобы расширить эти выражения без явным образом заданных предположений:
expand(ln(a^2), IgnoreAnalyticConstraints), expand(ln(a*b), IgnoreAnalyticConstraints), expand((a*b)^n, IgnoreAnalyticConstraints)
Теоремы сложения тригонометрии реализованы "expand"
- пазы тригонометрических функций sin
и cos
:
expand(sin(a + b)), expand(sin(2*a))
То же самое верно для гиперболических функций sinh
и cosh
:
expand(cosh(a + b)), expand(cosh(2*a))
Показательная функция с суммой в качестве аргумента расширена через exp::expand
:
expand(exp(a + b))
Вот являются еще некоторые примеры расширения для функций sum
, fact
abs
coth
знак
, binomial
\beta
\Gamma
раскладушка
tan
exp
и psi
:
sum(f(x) + g(x),x); expand(%)
fact(x + 1); expand(%)
abs(a*b); expand(%)
coth(a + b); expand(%)
coth(a*b); expand(%)
sign(a*b); expand(%)
binomial(n, m); expand(%)
beta(n, m); expand(%)
gamma(x + 1); expand(%)
tan(a + b); expand(%)
cot(a + b); expand(%)
exp(x + y); expand(%)
psi(x + 2); expand(%)
В отличие от предыдущих версий MuPAD, expand
не переписывает tan
в терминах sin
и cos
:
expand(tan(a))
Этот пример иллюстрирует, как расширить функциональность expand
к пользовательским математическим функциям. Как пример, мы рассматриваем синусоидальную функцию. (Конечно, системная функция sin
уже имеет "expand"
паз; смотрите Пример 10.)
Мы сначала встраиваем нашу функцию в функциональную среду, которая мы вызываем Sin
, для того, чтобы не перезаписать системную функцию sin
. Затем мы реализуем теорему сложения sin (x + y) = sin (x) cos (y) + sin (y) cos (x) в "expand"
паз функциональной среды, т.е. стандартная программа паза Sin::expand
:
Sin := funcenv(Sin): Sin::expand := proc(u) // compute expand(Sin(u)) local x, y; begin // recursively expand the argument u u := expand(op(u)); if type(u) = "_plus" then // u is a sum x := op(u, 1); // the first term y := u - x; // the remaining terms // apply the addition theorem and // expand the result again expand(Sin(x)*cos(y) + cos(x)*Sin(y)) else Sin(u) end_if end_proc:
Теперь, если expand
сталкивается с подвыражением формы Sin(u)
, это вызывает Sin::expand(u)
расширять Sin(u)
. Следующая команда сначала расширяет аргумент a*(b+c)
через рекурсивный вызов в Sin::expand
, затем применяет теорему сложения, и наконец expand
самостоятельно расширяет продукт результата с z
:
expand(z*Sin(a*(b + c)))
Расширение после приложения теоремы сложения в Sin::expand
необходимо, чтобы обработать случай когда u
сумма больше чем с двумя условиями: затем y
снова сумма и cos(y)
и Sin(y)
расширены рекурсивно:
expand(Sin(a + b + c))
|
|
Расширьте арифметическую часть выражения, не расширяя тригонометрические, гиперболические, логарифмические и специальные функции. Эта опция не предотвращает расширение степеней и корней. Технически, опция не использует перегрузку |
|
При использовании этой опции
Используя опцию может дать вам более простые результаты для выражений для который вызов по умолчанию |
|
Опция, заданная как Не расширяйте степени с целочисленными экспонентами, больше, чем Если вы вызываете |
f
С дополнительными аргументами g1, g2, ...
, расширение определенных подвыражений f
может быть предотвращен. Это работает можно следующим образом: каждое вхождение g1, g2, ...
inf
заменяется вспомогательной переменной перед расширением, и впоследствии вспомогательные переменные заменяются исходными подвыражениями.
Пользователи могут расширить функциональность expand
к их собственным специальным математическим функциям через перегрузку. С этой целью встройте свою функцию в функциональную среду g
и реализуйте поведение expand
для этой функции в "expand"
паз функциональной среды.
Каждый раз, когда expand
сталкивается с подвыражением формы g(u,..)
, это издает приказ g::expand(g(u,..))
к стандартной программе паза, чтобы расширить подвыражение, передавая еще расширенные аргументы g(u,..)
в качестве аргументов. Результат этого вызова не расширен дальше expand
. Смотрите пример 11 выше.
Точно так же "expand"
паз может быть задан для пользовательской библиотеки domainT
. Каждый раз, когда expand
сталкивается с подвыражением d
из области typeT
, это издает приказ T::expand(d)
к стандартной программе паза, чтобы расширить d
. Результат этого вызова не расширен дальше expand
. Если T
не имеет никакого "expand"
паз, затем d
остается неизменным.