rationalize

Преобразуйте выражение в рациональное выражение

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

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

Синтаксис

rationalize(object, options)

Описание

rationalize(object) преобразовывает выражение object в эквивалентное рациональное выражение, заменяя нерациональные подвыражения недавно сгенерированными переменными.

По умолчанию рациональное выражение является выражением, которое содержит только суммы, продукты, степени с целочисленными экспонентами, целыми числами, рациональными числами и идентификаторами как подвыражения.

Функция rationalize возвращает последовательность (rat, subsSet). Рационализированное выражение rat содержит новые переменные. Набор замен subsSet выражает новые переменные старыми единицами.

Если исходное выражение содержит подвыражения, функция rationalize может рационализировать или заменить подвыражения или сохранить их в их исходной форме. Используйте опции DescendInto, ReplaceType и StopOn, чтобы управлять мерами, которые rationalize принимает для конкретных типов подвыражений.

Если FindRelations = ["exp", "_power", "sin"], функция rationalize обнаруживает максимальное количество алгебраических зависимостей.

Если вы вызываете rationalize с какой-либо комбинацией следующих трех опций противоречия, функция выбирает опцию с помощью следующих приоритетов: ReplaceType, StopOn, DescendInto. Например, если вы задаете тот же тип подвыражения с StopOn и DescendInto, функция rationalize использует только опцию StopOn для подвыражений заданного типа. Если вы комбинируете какую-либо из этих опций с опцией ReplaceType, rationalize использует только опцию ReplaceType.

Примеры

Пример 1

rationalize работает с одним арифметическими выражениями, списками и наборами выражений:

rationalize(2*sqrt(3) + 0.5*x^3)

rationalize([(x - sqrt(2))*(x^2 + sqrt(3)),
             (x - sqrt(2))*(x - sqrt(3))])

Пример 2

Используйте опцию ApproximateFloats, чтобы заменить все числа с плавающей запятой на рациональные числа:

rationalize([0.4, 0.333, 0.74], ApproximateFloats)

Если вы используете и ApproximateFloats и опции ReplaceTypes, ApproximateFloats не применяется к типам подвыражений, заданных в ReplaceTypes:

rationalize(0.4*x^2 + sin(0.33/x),
                ApproximateFloats,
                ReplaceTypes={DOM_FLOAT})

Вместо того, чтобы задать значение ReplaceTypes как последовательность типов, можно задать его как функцию. Функция должна возвратить TRUE или FALSE в результате. Например, рационализируйте то же выражение. На этот раз используйте функциональный F, чтобы задать тип подвыражений, которые вы хотите заменить переменными:

F := X -> testtype(X, DOM_FLOAT):
rationalize(0.4*x^2 + sin(0.33/x),
                ApproximateFloats,
                ReplaceTypes = F)

Пример 3

По умолчанию rationalize рационализирует суммы, продукты, основы целочисленных степеней, списков и наборов:

rationalize(ln(sin(x)^2 + cos(x)*exp(x)))

Опция DescendInto позволяет вам задать типы подвыражений, которые вы хотите рационализировать. Каждый тип может быть доменным типом, строка, как возвращено функциональным type или Текстовым объектом. Обратите внимание на то, что DescendInto перезаписывает типы по умолчанию с типами, которые вы задаете:

rationalize(ln(sin(x)^2 + cos(x)*exp(x)), DescendInto = {"ln"})

Если вы хотите добавить новые типы подвыражений к единицам по умолчанию, задать значение DescendInto как процедура, которая задает все необходимые типы явным образом. Процедура должна возвратить TRUE или FALSE:

F := proc(X)
begin
  hastype(X, {"_plus", "_mult", DOM_SET, DOM_LIST, "ln"}) or
  (hastype(X, "_power") and hastype(op(X, 2), DOM_INT))
end:

rationalize(ln(sin(x)^2 + cos(x)*exp(x)), DescendInto = F)

Пример 4

Используйте опцию MinimalPolynomials, чтобы найти минимальные полиномы иррациональных выражений:

rationalize(x^(7/6) + x^(3/2), MinimalPolynomials)

Пример 5

Используйте Prefix = s, где s является строкой, чтобы задать префикс для сгенерированных переменных (префиксом по умолчанию является X):

rationalize(x^(7/6) + x^(3/2), Prefix = "ABC")

Пример 6

Используйте опцию ReplaceHardToEval, чтобы заменить пределы, суммы и интегралы со сгенерированными переменными. Выражения с пределами, суммами и интегралами имеют тенденцию быть наиболее в вычислительном отношении дороги:

rationalize(sum(exp(x)/(x^2 + 1), x) +
            limit(sin(cos(1/x))*cos(1/x), x),
                           ReplaceHardToEval)

Пример 7

По умолчанию rationalize избегает рационализации целых чисел, рациональных чисел и идентификаторов:

rationalize(2*sqrt(3) + 0.5*x^3)

Опция DescendInto позволяет вам избежать рационализации конкретных типов подвыражений. Каждый тип может быть задан как доменный тип, строка, как возвращено функциональным type или Текстовым объектом. Например, рационализируйте то же выражение, оставив подвыражение x^3 (типа "_power") неизменный:

rationalize(2*sqrt(3) + 0.5*x^3, StopOn = {"_power"})

Рационализируйте то же выражение включая все подвыражения. Сохраните числа с плавающей запятой, целые числа и идентификаторы (не заменяйте их на сгенерированные переменные):

rationalize(2*sqrt(3) + 0.5*x^3,
            StopOn = {DOM_FLOAT, DOM_INT, DOM_IDENT})

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

rationalize(2*sqrt(3) + 0.5*x^3,
            StopOn = {DOM_INT, DOM_IDENT, DOM_RAT, DOM_FLOAT})

rationalize(2*sqrt(3) + 0.5*x^3,
            StopOn = {DOM_INT, DOM_IDENT,
                      DOM_RAT, DOM_FLOAT,
                               "_power"})

Опция StopOn также может принять функцию как свое значение. Функция должна возвратить TRUE или FALSE. Например, используйте сгенерированные переменные, чтобы заменить только подвыражения, которые содержат sin. Сохраните все другие подвыражения в целости:

F := X -> not hastype(X, "sin"):
rationalize(sin(x^2) + x^3 + exp(x) + 1/x, StopOn = F)

Пример 8

Используйте опцию FindRelations, чтобы обнаружить алгебраические зависимости между экспоненциалами:

rationalize(exp(x/2) + exp(x/3), FindRelations = ["exp"])

Обнаружьте алгебраические зависимости для различных степеней той же основы путем определения типа "_power":

rationalize(x^(3/2) + x^(7/4), FindRelations = ["_power"])

Обнаружьте алгебраические зависимости для тригонометрических функций путем определения типа "sin" или "cos":

rationalize(sin(x) + cos(x), FindRelations = ["sin"]);
rationalize(sin(x)^3 + cos(x)^3, FindRelations = ["cos"])

Пример 9

Для вложенных экспоненциалов используйте опцию Recursive, чтобы получить список замен:

rationalize(exp(exp(x)), FindRelations = ["exp"], Recursive)

Опция также работает на тригонометрические функции:

rationalize(sin(sin(x)), FindRelations = ["sin"], Recursive)

Пример 10

Опция ShowDependencies показывает все исходные переменные, от которых зависит каждая сгенерированная переменная:

rationalize(sin(x)^3, ShowDependencies)

Параметры

object

Любой объект MuPAD®

Опции

ApproximateFloats

Когда вы используете опцию ApproximateFloats, функция rationalize заменяет числа с плавающей запятой на рациональные числа. По умолчанию, ApproximateFloats = FALSE: функция rationalize заменяет все числа с плавающей запятой на новые переменные. Если вы рационализируете выражение с помощью и ApproximateFloats и опций StopOn, StopOn не предотвращает рационализацию чисел с плавающей запятой в заданных подвыражениях. Если вы рационализируете выражение с помощью и ApproximateFloats и опций ReplaceTypes, ApproximateFloats не применяется к типам подвыражений, заданных в ReplaceTypes. Смотрите Пример 2.

DescendInto

Когда вы используете опцию DescendInto, функция rationalize рационализирует все подвыражения заданных типов. Можно задать значение этой опции как набор (даже если существует только один тип), или процедура, которая возвращает TRUE или FALSE. Каждый тип может быть

По умолчанию функция rationalize рационализирует следующие типы подвыражений: суммы, продукты, основы целочисленных степеней, списков и наборов. Когда вы задаете другие типы подвыражений, rationalize использует их вместо типов по умолчанию. (DescendInto перезаписывает типы по умолчанию с типами, которые вы задаете.), Если вы хотите расширить набор типов подвыражений, сохраняющих типы по умолчанию, задайте значение DescendInto как процедура, которая задает все значение по умолчанию и дополнительные типы явным образом. Смотрите Пример 3.

FindRelations

Когда вы используете опцию FindRelations, функция rationalize обнаруживает алгебраические зависимости для подвыражений заданных типов. Эта опция принимает типы подвыражений в форме списка. Следующие типы доступны: "sin", "cos", "exp" и "_power". По умолчанию rationalize не ищет зависимости для иррациональных подвыражений: FindRelations = [].

MinimalPolynomials

Когда вы используете опцию MinimalPolynomials, функция rationalize возвращает минимальные полиномы иррациональных выражений. Функция возвращает рационализированное выражение, набор уравнений замены и минимальные полиномы. По умолчанию, MinimalPolynomials = FALSE. Смотрите Пример 4.

Prefix

Используйте опцию Prefix, чтобы задать префикс для новых переменных, сгенерированных функцией rationalize. Значение этой опции должно быть строкой. По умолчанию, Prefix = "X". Смотрите Пример 5.

Recursive

Когда вы используете опцию Recursive, функция rationalize рекурсивно рационализирует вложенные подвыражения и возвращает список уравнений замены. Каждая сгенерированная переменная в возвращенном списке может зависеть от других переменных в списке. По умолчанию, Recursive = FALSE. Смотрите Пример 9.

ReplaceHardToEval

Когда вы используете опцию ReplaceHardToEval, функция rationalize заменяет все пределы, суммы и интегралы сгенерированными переменными. Обычно эта опция позволяет вам избегать большинства дорогих рационализаций сумм, пределов и интегралов. По умолчанию, ReplaceHardToEval = FALSE. Смотрите Пример 6.

ReplaceTypes

Когда вы используете опцию ReplaceTypes, функция rationalize заменяет все подвыражения заданных типов со сгенерированными переменными. Можно задать значение этой опции как набор (даже если существует только один тип), или процедура, которая возвращает TRUE или FALSE. Каждый тип может быть

Эта опция позволяет вам задавать и избегать большинства дорогих рационализаций для своего конкретного выражения. Если вы используете эту опцию в сочетании с ReplaceHardToEval, функция rationalize использует сгенерированные переменные, чтобы заменить все пределы, суммы, интегралы и типы, которые вы задаете. Если ReplaceTypes задает тот же тип подвыражения как DescendInto, опция ReplaceTypes преобладает. По умолчанию, ReplaceTypes = {}.

Также задайте значение этой опции как функция, которая возвращает TRUE или FALSE. Смотрите Пример 2.

ShowDependencies

Когда вы используете опцию ShowDependencies, функция rationalize заменяет любое иррациональное подвыражение, содержащее идентификаторы vars с выражением формы newvar(vars), показывая зависимости сгенерированных переменных на исходных переменных. По умолчанию, ShowDependencies = FALSE.

StopOn

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

По умолчанию функция rationalize не рационализирует или заменяет целые числа, рациональные числа и идентификаторы. Когда вы задаете другие типы подвыражений, rationalize использует их вместо типов по умолчанию. (StopOn перезаписывает типы по умолчанию с типами, которые вы задаете.), Если вы хотите расширить набор типов подвыражений, сохраняющих типы по умолчанию, задайте StopOn = {DOM_INT, DOM_IDENT, DOM_RAT, extra types}, где extra types является дополнительными типами подвыражений, которые вы не хотите рационализировать. Смотрите Пример 7.

Если StopOn задает тот же тип подвыражения как DescendInto, опция StopOn преобладает.

StopOnConstants

Когда вы используете опцию StopOnConstants, функция rationalize не рационализирует объект типа Type::Constant: числа, строки, булевы константы, NIL, FAIL, PI, ЭЙЛЕР и CATALAN в наборе Type::ConstantIdents. По умолчанию, StopOnConstants = FALSE.

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

Последовательность, состоящая из рационализированного объекта и набор уравнений замены. Если вы используете опцию Recursive, функция rationalize возвращает список уравнений замены вместо набора. Если вы используете опцию MinimalPolynomials, возвращенное значение имеет третий аргумент: минимальные полиномы.

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

Функции MuPAD

Для просмотра документации необходимо авторизоваться на сайте