piecewise

Область условно заданных объектов

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

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

Синтаксис

piecewise([cond1, value1], [cond2, value2], …, <[Otherwise, valueN]>, <ExclusiveConditions>)

Описание

piecewise([cond1, value1], [cond2, value2], ...) задает условный объект, который равняется value1, если cond1 доказуемо верен, value2, если cond2 доказуемо верен и так далее. Как правило, такие объекты задают кусочные функции или выражают решения на основе анализа случая свободных параметров математической проблемы. Смотрите Пример 1.

Парный [condition, value] называется ответвлением. Если condition является доказуемо ложным, то piecewise отбрасывает целое ответвление. Если condition доказуемо верен, то piecewise возвращает соответствующий value. Если никакое условие в кусочном объекте не доказуемо верно, piecewise возвращает объект типа piecewise, который содержит все ответвления, за исключением ответвлений с доказуемо ложными условиями.

Если все условия являются доказуемо ложными, или если вы вызываете piecewise без каких-либо ответвлений, то piecewise возвращает undefined. Смотрите Пример 1.

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

Если несколько условий одновременно верны, piecewise возвращает значение от первого ответвления, которое содержит условие, распознанное верным. Гарантируйте, что все значения, соответствующие истинным условиям, имеют то же математическое значение. Не полагайтесь на систему, чтобы распознать первое математически истинное условие верным. Также можно использовать опцию ExclusiveConditions, чтобы зафиксировать порядок ответвлений.

piecewise([cond1, value1], [cond2, value2], ..., [Otherwise, valueN]) проверяет условия, и, если они не удовлетворены, отбрасывания их, и возвращает valueN. Условие Otherwise происходит в последнем ответвлении. Это может произойти только однажды. Это остается неизменным пока существуют другие ответвления, но это обработано как верное, когда все другие ответвления отбрасываются, потому что их условия ложные. Смотрите Пример 2.

Система проверяет истину условий для текущих значений и свойств всех включенных идентификаторов каждый раз, когда это оценивает объект типа piecewise. Таким образом это упрощает кусочные выражения под всевозможными предположениями.

Объекты piecewise могут быть вложены: и условия и значения могут быть самими объектами piecewise. piecewise автоматически “сглаживает” такие объекты. Например, piecewise([conditionA, piecewise([conditionB, valueC])]) становится piecewise([conditionA and conditionB, valueC]). Смотрите Пример 3.

Арифметические и относящиеся к теории множеств операции работают на объекты piecewise, если эти операции заданы для всех значений, содержавшихся в ответвлениях. Если f является такой операцией, и p1, p2, ... объекты piecewise, то f(p1, p2, ...) является объектом piecewise, состоящим из всех ответвлений формы [cond1 and cond2 and ..., f(value1, value2, ...)], где [cond1, value1] является ответвлением p1, [cond2, value2] является ответвлением p2 и так далее. Другими словами, применение f коммутируется с любым присвоением на свободные параметры в условиях. Смотрите Пример 4.

Объекты piecewise могут также быть смешаны с другими объектами в таких операциях. В таких случаях, если p1 не является объектом piecewise, система обрабатывает его как объект piecewise с единственным ответвлением [TRUE, p1]. Смотрите Пример 5.

diff, float, limit, int и подобные функции обрабатывают выражения, включающие piecewise. Когда вы используете аргумент piecewise в унарных операторах и функциях с одним аргументом, система сопоставляет оператор или функцию к значениям в каждом ответвлении. Смотрите Пример 6, Пример 7 и Пример 8.

piecewise отличается от if и операторов ветвления case. Во-первых, piecewise использует механизм свойства при решении истины условий. Поэтому результат зависит от свойств идентификаторов, которые появляются в условиях. Во-вторых, piecewise обрабатывает условия математически, в то время как if и case оценивают их синтаксически. В-третьих, piecewise внутренне сортирует ответвления. Если условия в нескольких ответвлениях верны, piecewise может возвратить любое из этих ответвлений. Смотрите Пример 9.

Опция ExclusiveConditions фиксирует порядок ответвлений в кусочном выражении. Если условие в первом ответвлении возвращает TRUE, то piecewise возвращает значение от первого ответвления. Если истинное условие появляется в дальнейшем ответвлении, то piecewise возвращает значение от того ответвления и удаляет все последующие ответвления. Таким образом piecewise с ExclusiveConditions очень похож на оператор if-elif-end_if. Тем не менее, piecewise с ExclusiveConditions все еще учитывает предположения на идентификаторах и обрабатывает условия математически, в то время как if-elif-end_if обрабатывает их синтаксически. Смотрите Пример 10.

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

piecewise учитывает свойства идентификаторов.

Примеры

Пример 1

Задайте этот прямоугольный функциональный f. Без дополнительной информации о переменной x система не может оценить условия к TRUE или FALSE. Поэтому это возвращает объект piecewise.

f := x -> piecewise([x < 0 or x > 1, 0], [x >= 0 and x <= 1, 1])

Вызовите функциональный f со следующими аргументами. Каждый раз, когда вы вызываете эту кусочную функцию, система проверяет условия в свои ответвления и выполняет функцию.

f(0), f(2), f(I)

Пример 2

Создайте эту кусочную функцию с помощью синтаксиса, который включает Otherwise:

pw:= piecewise([x > 0 and x < 1, 1], [Otherwise, 0])

Оцените pw для этих трех значений:

pw | x = 1/2;
pw | x = 2;
pw | x = I;

Для дальнейших вычислений удалите идентификатор pw:

delete pw:

Пример 3

Создайте это вложенное кусочное выражение. MuPAD® сглаживается, вложил объекты piecewise.

p1 := piecewise([a > 0, a^2], [a <= 0, -a^2]):
piecewise([b > 0, a + b], [b = 0, p1 + b], [b < 0, a + b])

Пример 4

Найдите сумму этих кусочных функций. Можно выполнить большинство операций на кусочных функциях тот же путь, как вы были бы по обычным арифметическим выражениям. Результат арифметической операции только задан в точках, где все аргументы заданы:

piecewise([x > 0, 1], [x < -3, x^2]) + piecewise([x < 2, x])

Пример 5

Решите это уравнение. Решатель возвращает результат как кусочный набор:

S := solve(a*x = 0, x)

Можно использовать относящиеся к теории множеств операции, работают на такие наборы. Например, найдите пересечение этого набора и интервала (3, 5):

S intersect Dom::Interval(3, 5)

Пример 6

Много унарных функций перегружаются для piecewise путем отображения их с объектами во всех ответвлениях входа:

f := piecewise([x >= 0, arcsin(x)], [x < 0, arccos(x)]):
sin(f)

Пример 7

Найдите предел этой кусочной функции:

limit(piecewise([a > 0, x],[a < 0 and x > 1, 1/x],
                [a < 0 and x <= 1, -x]), x = infinity)

Пример 8

Найдите интеграл этой кусочной функции:

int(piecewise([x < 0, x^2], [x > 0, x^3]), x = -1..1)

Пример 9

Создайте эту кусочную функцию. Здесь, piecewise не может определить, является ли какое-либо ответвление TRUE или FALSE. Чтобы сделать это, piecewise нужна дополнительная информация об идентификаторе a.

p1 := piecewise([a = 0, 0], [a <> 0, 1/a])

Создайте подобную структуру при помощи if-then-else. Структура if-then-else оценивает условия синтаксически. Здесь, a = 0 является технически ложным, потому что идентификатор a и целочисленный 0 является различными объектами.

p2 := (if a = 0 then 0 else 1/a end)

piecewise принимает свойства во внимание идентификаторов:

p1 := piecewise([a + b = 0, 0], [Otherwise, 1/a]) assuming a + b = 0

if-then-else не делает:

p2 := (if a + b = 0 then 0 else 1/a end) assuming a + b = 0

Для дальнейших вычислений удалите идентификаторы a, b, p1 и p2:

delete a, b, p1, p2:

Пример 10

Создайте это кусочное выражение:

p := piecewise([x > 0, 1], [y > 0, 2])

Выполните выражение в y = 1:

p | y = 1

Теперь, создайте кусочное выражение с теми же ответвлениями, но на этот раз используйте ExclusiveConditions, чтобы зафиксировать порядок ответвлений. Когда вы используете эту опцию, любое ответвление может быть верным, только если предыдущие ответвления являются ложными.

pE := piecewise([x > 0, x], [y > 0, y], ExclusiveConditions)

Выполните выражение в y = 1:

pE | y = 1

Когда вы используете ExclusiveConditions, piecewise действует одинаково как оператор if-then-else, но не игнорирует свойства идентификаторов. Например, установите предположение что x = 0:

assume(x = 0)

Вызов функции piecewise возвращается 0, потому что он использует предположение на идентификаторе x:

p := piecewise([x = 0, x], [Otherwise, 1/x^2])

Соответствующий оператор if-then-else игнорирует предположение, и, поэтому, возвращает 1/x^2:

pIf := (if x = 0 then x else 1/x^2 end)

Для дальнейших вычислений удалите идентификаторы p, pE, x и pIf:

delete p, pE, x, pIf:

Пример 11

Найдите набор предельных точек этой кусочной функции путем вызова limit с опцией Intervals:

limit(piecewise([a > 0, sin(x)], [a < 0 and x > 1, 1/x],
         [a < 0 and x <= 1, -x]), x = infinity, Intervals)

Пример 12

Перепишите функцию sign с точки зрения объекта piecewise:

f := rewrite(sign(x), piecewise)

Пример 13

Создайте этот объект piecewise:

f := piecewise([x > 0, 1], [x < -3, x^2])

Извлеките конкретное условие или объект:

piecewise::condition(f, 1), piecewise::expression(f, 2)

Индексный оператор имеет то же значение как piecewise::expression и может быть введен быстрее:

f[2]

Функция piecewise::branch извлекает целые ответвления:

piecewise::branch(f, 1)

Можно сформировать другой объект piecewise из ответвлений, для которых условие удовлетворяет данный критерий выбора или разделило вход в два объекта piecewise как системные функции, select и split делают это для списков:

piecewise::selectConditions(f, has, 0)

piecewise::splitConditions(f, has, 0)

Можно также создать копию f с некоторыми ответвлениями, добавленными или удаленными:

piecewise::remove(f, 1)

piecewise::insert(f, [x > -3 and x < 0, sin(x)])

Параметры

cond1, cond2, …

Булевы константы или выражения, представляющие логические формулы

object1, object2, …

Произвольные объекты

Otherwise

Идентификатор, который задает последнее условие. Это условие всегда обрабатывается как истинное условие.

Опции

ExclusiveConditions

Опция ExclusiveConditions фиксирует порядок ответвлений в кусочном выражении. Эта опция заставляет piecewise автоматически удалять ответвления с ложными условиями. Таким образом piecewise с ExclusiveConditions почти эквивалентен оператору if-elif-end_if, за исключением того, что piecewise учитывает предположения на идентификаторах. Например, если условие в первом ответвлении возвращает TRUE, то piecewise возвращает выражение в первое ответвление. Если истинное условие появляется в дальнейшем ответвлении, то piecewise возвращает выражение в то ответвление и удаляет все последующие ответвления.

Методы

развернуть все

Математические методы

_in(p, S)

contains(p, a)

Этот метод перегружает функциональный contains. Значения во всех ответвлениях должны быть допустимыми первыми аргументами для contains.

diff(p, <x, …>)

Если никакие переменные не даны, p возвращен.

discont(p, x, <F>)

discont(p, x = a .. b, <F>)

Значения во всех ответвлениях p должны быть арифметическими выражениями.

Дополнительный третий параметр имеет то же значение что касается функционального discont.

Что касается функционального discont, только разрывы в данном интервале [a,b] возвращены при вызове piecewise(p, x = a..b).

disregardPoints(p)

expand(p)

factor(p)

getElement(p)

Результатом является FAIL, если никакой такой общий элемент не найден.

Этот метод перегружает функциональный solvelib::getElement.

has(p, a)

int(p, x, <r>)

Если область значений, которую a..b дан, этот метод, вычисляет определенный интеграл p, когда x пробегает ту область значений.

ilaplace(p, x, t)

isFinite(p)

Этот метод перегрузки solvelib::isFinite.

laplace(p, x, t)

limit(p, x, <Left | Right | Real>, <Intervals>, <NoWarning>)

limit(p, x = x0, <Left | Right | Real>, <Intervals>, <NoWarning>)

Когда названо опцией Intervals, метод возвращает набор предельных точек функции.

Если метод не может найти функциональный предел и не может доказать, что предел не существует, вызов функции возвращает неоцененную функцию limit.

Если предел функции не существует, метод возвращает специальное значение undefined.

Этот метод перегружает функциональный limit.

normal(p)

partfrac(p)

restrict(p, C)

set2expr(p, x)

Объекты во всех ответвлениях p должны представлять наборы.

Этот метод перегружает системную функцию _in.

simplify(p)

solve(p, x, <option1, option2, …>)

Для каждого ответвления [condition, value] p, с value, являющимся уравнением или неравенством, метод, определяет набор всех значений x, таким образом, что и condition и value становятся верными математически, и возвращает объединение всех полученных наборов. Возвращаемое значение может быть условно заданным набором.

Этот метод перегружает функциональный solve. Смотрите соответствующую страницу справки для описания доступных параметров и обзора типов наборов, которые могут быть возвращены.

solveConditions(p, x)

Union(p, x, indexset)

Значения во всех ответвлениях p должны представлять наборы.

Для каждого ответвления [condition, value] p этот метод делает следующее. Это заменяет x в value всеми значениями от indexset, удовлетворяющего condition, и берет объединение по всем полученным наборам. Затем это возвращает объединение по получившимся наборам для всех ответвлений.

Этот метод перегружает функциональный solvelib::Union.

Методы доступа

_concat(p, …)

branch(p, n)

op(p)

op(p, n)

op(p, n) возвращает n th ответвление p как список. Если n = 0, то piecewise возвращен.

setBranch(p, i, b)

numberOfBranches(p)

condition(p, i)

setCondition(p, i, cond)

expression(p, i)

Вместо piecewise::expression(p, i) индексный оператор p[i] может использоваться синонимично.

_index(p, i)

piecewise::expression может использоваться синонимично.

setExpression(p, i, a)

insert(p, b)

b может или быть ответвлением, извлеченным от другого условно заданного объекта с помощью extop или списка [condition, object].

Смотрите пример 13.

extmap(p, f, <a, …>)

mapConditions(p, f, <a, …>)

map(p, f, <a, …>)

map(p, f) эквивалентен piecewise::extmap(p, map, f).

remove(p, i)

splitBranch(p, i, newcondition)

selectConditions(p, f, <a, …>)

Для каждого условия в p f(condition a, …) должен возвратить булеву константу.

Если ни одно из условий не удовлетворяет критерий выбора, undefined возвращен.

selectExpressions(p, f, <a, …>)

Для каждого значения в p f(value a, …) должен возвратить булеву константу.

Если ни один из объектов не удовлетворяет критерий выбора, undefined возвращен.

splitConditions(p, f, <a, …>)

Для каждого условия в p f(condition a, …) должен возвратить булеву константу.

Смотрите пример 13.

subs(p, s, …)

Этот метод перегружает функциональный subs. Синтаксис вызова идентичен этой функции. Смотрите соответствующую страницу справки для описания различных типов, которые позволены для s.

zip(p1, p2, f)

Если мы рассматриваем условно заданные объекты как функции от набора A значений параметров к набору B объектов, этот метод реализует каноническое расширение бинарной операции f на B к бинарной операции g на съемочной площадке B A всех функций от A до B через g (p1, p2) (a) = f (p1 (a), p2 (a)) для всего a в A.

Если только один из первых двух аргументов — p1, говорят — имеет тип piecewise, то каждое ответвление [condition, value] p1 заменяется [condition, f(value, p2)].

Если ни p1, ни p2 не имеют типа piecewise, то piecewise::zip(p1, p2, f) возвращает f(p1, p2).

Алгоритмы

Операнды объекта piecewise (ответвления) являются парами, состоящими из условия и значения, допустимого при том условии.

Методы, перегружающие системные функции всегда, принимают, что были названы через перегрузку, и что существует некоторый условно заданный объект среди их аргументов. Все другие методы не принимают, что один из их аргументов имеет тип piecewise. Это упрощает использование piecewise: всегда позволяется ввести p:=piecewise(...) и вызвать некоторый метод piecewise с p в качестве аргумента. Вы не должны заботиться об особом случае, где p не имеет типа piecewise, потому что некоторое условие в его определении верно, или все условия являются ложными.

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

Функции MuPAD

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