What is the recommended way to define numeric function with special cases?

Question

What is the recommended way to define a purely numeric function with special cases? Should I define many special cases with pattern matching?

(*TOY EXAMPLE*)
f[a_,b_]/;a>b := Sin[a-b];
f[a_,b_]/;a<b := Tan[a/b];
f[a_,b_]/;a==b := Cos[a+b];

or should I use Piecewise?

f[a_,b_] := Piecewise[{{Sin[a-b],a>b},{Tan[a/b],a<b},{Cos[a+b],a==b}}]

or should I use UnitStep? How about If statements?

Also What about if the function is continuous across each segments (not like the toy example above)? and if the function is smooth?

I gave a brief answer below with my own opinions. Later I shall try to add examples to support my statements if someone has not already provided a better answer by that time. — Mr.Wizard, Sep 28 '14 at 17:05
Use PieceWise, UnitStep and friends, if you want your function to integrate well with mathematical functionality such as simplifications, etc. Otherwise use rules. The If is inferior to both of those ways, in most cases. — Leonid Shifrin, Sep 28 '14 at 17:06
@LeonidShifrin Do you really think If is inferior when it concerns purely numeric functions? I wonder why that would be the case. Of course it's not usually equally aesthetic, but is there another reason you're thinking about? I guess the question doesn't really define the functions as purely numeric, so you're right if one admits that symbolic simplifications could still be performed. Thinking about it, it would be best if the question were made more specific. — Jens, Sep 28 '14 at 17:48
@Jens Two reasons: it makes the code harder to extend (and actually, harder to read) and more error-prone when there are several branches (you would need nested If or Which), and also it tends to be somewhat slower (not by much). But, I'd agree that this is largely a matter of taste. Philosophically, the closer you are to the core language constructs, the better, and patterns / rules are certainly closer to the core than the If/Which statements, because the core of Mathematica is a term-rewriting engine. — Leonid Shifrin, Sep 28 '14 at 18:07
I really think the question needs to be made more precise. First of all, the definitions in the example are contradictory. Second, what do you want to do with the function? — Jens, Sep 28 '14 at 20:34
If/Which and conditional pattern methods will not be handled well by either the algebra (Solve family) or calculus (continuous and discrete) functions. — Daniel Lichtblau, Sep 28 '14 at 21:20
@Jens thanks for pointing out the contraction. It is fixed. Also, the main use of the function is to carry out NIntegrate, to Plot and for carrying out statistical analysis (fitting functions involving f to data, etc..) — QuantumDot, Sep 29 '14 at 09:22
@LeonidShifrin and @Daniel Thanks for explanation! I would by default also prefer Piecewise, but was thinking there must also be examples where If could be better (e.g. if one really wants to prevent even symbolic evaluation of one alternative under all circumstances). — Jens, Sep 29 '14 at 15:31
@QuantumDot FYI-- From NIntegrate: "NIntegrate symbolically analyzes its input to transform oscillatory and other integrands, subdivide piecewise functions, and select optimal algorithms." From Plot: "Use automatic methods for computing exclusions, in this case for a piecewise function:..." UnitStep is vectorized and efficient on packed arrays, which may not apply to your use-cases. Finally, there's PIecewiseExpand, which can convert If, Which, and UnitStep to Piecewise. — Michael E2, Sep 29 '14 at 16:40

score 4 · Accepted Answer · answered Sep 28 '14 at 17:05

From testing in version 7, which I have not yet repeated in version 10, I recommend that you use your first form, as I found it to have at least a small performance advantage over Piecewise etc. I also find it very readable.

If you can reformulate your function for application to vectors then the use of UnitStep etc., where possible without being overly contrived, may be considerably faster. I see that as a special optimization technique however, not a matter of standard practice.

One place that Piecewise, Switch etc. can be easier to use is if you wish to programmatically manipulate the function.

Regarding Also I think I need an example of what you mean by "continuous across each segments."

Jens · Answer 2 · 2014-09-29T16:59:39.073

2

In general, I'd also use Piecewise because it's clearest.

However, to play devil's advocate, here is an example of where Piecewise is not the best choice (at least in Mathematica version 10.0.0):

Plot[
 Piecewise[{{Sin[x], {x, 0} ∈ 
     ImplicitRegion[-1 < x < 1, {x, y}]}, {1, True}}], {x, -2, 2}]

bug

The warning here seems to be due to the fact that Piecewise holds all its arguments and then analyzes the conditions in a form that has not been fully evaluated. At that stage it doesn't recognize the new region functionality and spits out the warning. Fortunately, the rest of the calculation is correct, but clearly the warning is incorrect. This is most likely a bug in Plot (and appears to have been fixed in version 10.0.1 on Mac as per Michael's comment below), and it can be circumvented by using If because the condition in If is not held unevaluated:

Plot[
 If[{x, 0} ∈ ImplicitRegion[-1 < x < 1, {x, y}], Sin[x], 
  1], {x, -2, 2}]

With this you get the same plot but no warnings.

Here the difference is that If has attribute HoldRest whereas Piecewise has attribute HoldAll, which we don't want.

Assuming this bug will get fixed, the fact remains that the different Hold... attributes of If may in certain cases make it the more natural choice, compared to Piecewise. If that happens, the choice would be more between If and pattern-based alternatives. Then the decision could still depend on other details, such as whether you intend to Compile the function.

edited Sep 29 '14 at 16:59

answered Sep 29 '14 at 16:37

Jens

97,245
7
213
499

The first example, http://i.stack.imgur.com/LUovE.png, works in V10.0.1, Mac OS 10.9.5. – Michael E2 Sep 29 '14 at 16:44
@MichaelE2. Interesting. The plot generated also looks different. – RunnyKine Sep 29 '14 at 16:49
@MichaelE2 Thanks, I added that info. – Jens Sep 29 '14 at 16:53
1

Actually, it is not fixed in Windows. I'm also using V10.0.1. – RunnyKine Sep 29 '14 at 16:54
@RunnyKine OK thanks, I edited that in as well... – Jens Sep 29 '14 at 16:58
@RunnyKine How odd. I wonder how that would depend on system stuff -- GPU? I assume the plot looks different because Exclusions has been fixed (in the Mac version). I would have thought that was a Mathematica programming bug, not a system bug. – Michael E2 Sep 29 '14 at 17:10
@MichaelE2, I'm perplexed by it myself. – RunnyKine Sep 29 '14 at 17:14

score 1 · Answer 3 · answered Sep 29 '14 at 14:26

Option 1 : Condition

f[a_,b_]/;a>b := Sin[a-b];
f[a_,b_]/;a<b := Tan[a/b];
f[a_,b_]/;a==b := Cos[a+b];

Option 2 : Piecewise

f[a_,b_] :=
  Piecewise[{
    {Sin[a-b], a>b}, 
    {Tan[a/b], a<b},
    {Cos[a+b], a==b}
  }]

Option 3 : Which

Which[
  a>b,Sin[a-b],
  a<b,Tan[a/b]
  a==b,Cos[a+b]
]

Option 4 : If

If[a>b,
  Sin[a-b],
  IF[a<b,Tan[a/b], Cos[a+b]]
]

I left out options Pattern test(?), Switch, Boole and others that are derived from them, like Cases, Except...

As personal preference I tend to use option 2 and Boole. If you ask why Boole then I would answer :

 PiecewiseExpand[Boole[a]]

enter image description here

There are more then 1 reason I do this, but mostly they are named in manual under details.

What is the recommended way to define numeric function with special cases?

3 Answers3

Linked