PiecewiseExpand
PiecewiseExpand[expr]
expands nested piecewise functions in expr to give a single piecewise function.
PiecewiseExpand[expr,assum]
expands piecewise functions using assumptions.
PiecewiseExpand[expr,assum,dom]
does the expansion over the domain dom.
Details and Options
- The result from PiecewiseExpand[expr] is normally Piecewise[{e1,e2,…}] where none of the ei contain Piecewise.
- PiecewiseExpand converts such functions as If, Which, Abs, Max, UnitStep, and Floor to Piecewise.
- PiecewiseExpand[expr,assum,dom] assumes that both the input and output of every function appearing in expr are in the domain dom.
- Common choices for dom are Reals and Complexes.
- PiecewiseExpand attempts to simplify combinations of conditions that appear in Piecewise.
- The following options can be given:
-
Assumptions $Assumptions default assumptions to append to assum Method Automatic method to use TimeConstraint 30 for how many seconds to try simplifying each set of conditions
Examples
open all close allBasic Examples (1)
Expand a nested piecewise expression to a single piecewise function:
Piecewise[{{Piecewise[{{1, x < 1}}, 2], x > 0}}, 3]PiecewiseExpand[%]Convert a composition of special piecewise functions to a single Piecewise object:
If[x > 0, Max[x, y], UnitStep[y]]PiecewiseExpand[%]Scope (5)
Expand a piecewise function with piecewise values and piecewise conditions:
Piecewise[{{Piecewise[{{1, x ≥ 0}}, 2], Piecewise[{{x, x ≤ 1}}, x / 2] ^ 2 ≥ 1 / 2}}, 3]PiecewiseExpand[%]PiecewiseExpand[Max[a, b, c, d]]Expand functions with infinite numbers of pieces over a finite region:
PiecewiseExpand[Floor[x], 0 < x < 4]PiecewiseExpand[PrimePi[x], 0 < x < 6]Expand a Boolean expression that implies a finite number of possible cases:
PiecewiseExpand[0 < Floor[x + Round[x ^ 2]] - x < 4]Expand assuming real parameters:
PiecewiseExpand[Max[Abs[x], Abs[y]], Reals]Options (11)
Assumptions (3)
Assumptions can be given both as an argument and as an option value:
PiecewiseExpand[Floor[x], x > 0, Assumptions -> x < 3]The default value of Assumptions option is $Assumptions:
Assuming[0 < x < 3, PiecewiseExpand[Floor[x]]]When assumptions are given as an argument, $Assumptions is used as well:
Assuming[x ^ 2 < 3, PiecewiseExpand[Floor[x] + Round[y], y ^ 2 < 2]]Specifying assumptions as an option value prevents using $Assumptions:
Assuming[x ^ 2 < 3, PiecewiseExpand[Floor[x] + Round[y], Assumptions -> y ^ 2 < 2]]Method (6)
The Method option allows local setting of system options related to piecewise functions:
SystemOptions["PiecewiseOptions"]With the default condition simplifier, some conditions may not be simplified:
pw = Min[x ^ 2 + 2x - 2, Max[2x ^ 2 - 3x + 4, x ^ 2 - 3]];PiecewiseExpand[pw]This uses Reduce to simplify conditions:
PiecewiseExpand[pw, Method -> {"ConditionSimplifier" -> Reduce}]By default, PiecewiseExpand uses Together to simplify values:
pw = UnitStep[x + 1] - UnitStep[x - 1](Sin[x] ^ 2 + Cos[x] ^ 2) + 1Trigonometric identities are not recognized:
PiecewiseExpand[pw]This uses Simplify to simplify values:
PiecewiseExpand[pw, Method -> {"ValueSimplifier" -> Simplify}]By default, conditions produced by PiecewiseExpand are not disjoint and cannot be reordered:
pw = Piecewise[{{Piecewise[{{Piecewise[{{4, a}}, 2], b}}, 3], c}}, 1]PiecewiseExpand[pw]This makes the conditions disjoint:
PiecewiseExpand[pw, Method -> {"OrderlessConditions" -> True}]By default, all special piecewise functions are converted to Piecewise:
pw = If[x > 0, UnitStep[x - 1], Max[x, y]];PiecewiseExpand[pw]This converts If and UnitStep, but not Max:
PiecewiseExpand[pw, Method -> {"ExpandSpecialPiecewise" -> {If, UnitStep}}]By default, explicitly Boolean valued piecewise functions are given as Boolean expressions:
PiecewiseExpand[-1 ≤ Max[x, y] ≤ 1]With "BooleanResult"->False, the expression is represented using Piecewise:
PiecewiseExpand[-1 ≤ Max[x, y] ≤ 1, Method -> {"BooleanResult" -> False}]With "BooleanResult"->True, all values are assumed to be Boolean:
PiecewiseExpand[If[a, b, c]]PiecewiseExpand[If[a, b, c], Method -> {"BooleanResult" -> True}]TimeConstraint (2)
Simplification of a piecewise function can take a long time:
PiecewiseExpand[Max[x ^ 6 + y ^ 6 + z ^ 6 - x y z, 0], (x - 1) ^ 2 + (y - 1) ^ 2 + (z - 1) ^ 2 ≤ 1 / 4]//TimingIf neither of the cases can be eliminated, checking this may still take a long time:
PiecewiseExpand[Max[x ^ 6 + y ^ 6 + z ^ 6 - x y z, 0], (x - 1) ^ 2 + (y - 1) ^ 2 + (z - 1) ^ 2 ≤ 1 / 2]//TimingThis restricts the time used for a single condition check; the result may be less simplified:
PiecewiseExpand[Max[x ^ 6 + y ^ 6 + z ^ 6 - x y z, 0], (x - 1) ^ 2 + (y - 1) ^ 2 + (z - 1) ^ 2 ≤ 1 / 4, TimeConstraint -> 1]//TimingPiecewiseExpand[Max[x ^ 6 + y ^ 6 + z ^ 6 - x y z, 0], (x - 1) ^ 2 + (y - 1) ^ 2 + (z - 1) ^ 2 ≤ 1 / 2, TimeConstraint -> 1]//TimingProperties & Relations (11)
PiecewiseExpand returns a single Piecewise object:
pw = Boole[x ≥ y ^ 2] + Piecewise[{{Max[x, y], x ≥ 0}, {UnitStep[x + 2], x > -5}}, y]PiecewiseExpand[pw]Min, Max, UnitStep, and Clip are piecewise functions of real arguments:
PiecewiseExpand /@ {Min[x, y], Max[x, y, z], UnitStep[x], Clip[x, {a, b}]}Abs, Sign, and Arg are piecewise functions when their arguments are assumed to be real:
Assuming[Element[x, Reals], PiecewiseExpand /@ {Abs[x], Sign[x], Arg[x]}]KroneckerDelta and DiscreteDelta are piecewise functions of complex arguments:
PiecewiseExpand /@ {KroneckerDelta[x, y], DiscreteDelta[x, y]}Boole is a piecewise function of a Boolean argument:
PiecewiseExpand[Boole[a]]If, Which, and Switch can be interpreted as piecewise functions:
PiecewiseExpand /@ {If[a, x, y], Which[a, x, b, y, c, z], Switch[u, v, x, w, y]}Convert Floor, Ceiling, Round, IntegerPart, and FractionalPart for finite ranges:
Assuming[{0 ≤ x ≤ 3}, PiecewiseExpand /@ {Floor[x], Ceiling[x], Round[x], IntegerPart[x], FractionalPart[x]}]Convert Mod and Quotient when the number of cases is finite:
Assuming[0 ≤ k ≤ 3m, PiecewiseExpand /@ {Mod[k, m], Quotient[k, m]}]UnitBox and UnitTriangle are piecewise functions of real arguments:
PiecewiseExpand /@ {UnitBox[x], UnitTriangle[x]}Convert SquareWave, TriangleWave, and SawtoothWave for finite ranges:
Assuming[{0 ≤ x ≤ 3}, PiecewiseExpand /@ {SquareWave[x], TriangleWave[x], SawtoothWave[x]}]BernsteinBasis and BSplineBasis are piecewise functions of real arguments:
PiecewiseExpand /@ {BernsteinBasis[3, 2, x], BSplineBasis[3, 2, x]}Possible Issues (1)
The number of cases in the expanded form may grow exponentially:
f[i_Integer, n_Integer, x_] := Piecewise[{{2 ^ (i - 1), Or @@ Table[j <= x < j + 2 ^ (i - 1), {j, 2 ^ (i - 1), 2 ^ n, 2 ^ i}]}}]The 
element of sums is a sum of 
piecewise functions with two cases each:
sums = Table[Sum[f[i, n, x], {i, n}], {n, 10}];The number of cases in the expanded form of the 
element of sums is 
:
Length[First[PiecewiseExpand[#]]] + 1& /@ sumsThis shows graphs of summands in the fourth element of sums; their sum is shown in red:
{Plot[Evaluate@Table[f[i, 4, x], {i, 4}], {x, 0, 16}, PlotRange -> {0, 16}],
Plot[Evaluate@Sum[f[i, 4, x], {i, 4}], {x, 0, 16}, PlotStyle -> Red]}Text
Wolfram Research (2004), PiecewiseExpand, Wolfram Language function, https://reference.wolfram.com/language/ref/PiecewiseExpand.html.
CMS
Wolfram Language. 2004. "PiecewiseExpand." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/PiecewiseExpand.html.
APA
Wolfram Language. (2004). PiecewiseExpand. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/PiecewiseExpand.html