# Function argument to default under certain condition

Inspired by this and this question (and how I handle this in practice), what is the best way to default a function value when a certain condition is met?

For example, if a function is defined as:

func[x_] := (x - 1)^2 + 5


and for values of x less than 0, x should equal zero. I also always want the function to evaluate even when x is less than 0. Normally, I would handle as such:

func2[x_] := Module[{xx = x},
If[xx < 0, xx = 0];
(xx - 1)^2 + 5]


If I try to use patterns to define the conditions, I have to define the function twice for each region:

func3[x_?Positive] := (x - 1)^2 + 5
func3[x_] := 6


I've had no luck using other patterns to define the function.

While this is an admittedly easy example that can be easily handled using Max[x,0], etc., patterns can be much more complex such as "integers divisible by a prime number".

So, can a pattern married with a default argument handle this situation? And what is the most efficient on a computation and memory basis?

UPDATE:

Here is a more complicated version of a function to which I referred to in the comments:

func[qi_, dei_, b_, dmin_, rt_, pt_, t_] :=
Module[{ptt = Max[pt, 0], rtt = Max[rt, 0], di, diexp, xotime, xorate},
di = 1/b*((1 - dei)^-b - 1)/365;
diexp = -Log[1 - dmin]/365;
xotime = (di - diexp)/(di*b*diexp) + rtt + ptt;
xorate = qi*(1 + b*di*(xotime - ptt - rtt))^(-1/b);
Piecewise[{{qi/2 (1 + t/rtt), t <= rtt}, {qi, rtt < t <= (rtt + ptt)},
{qi*(1 + b*di*(t - rtt - ptt))^(-1/b), (rtt + ptt) < t <= xotime},
{xorate*Exp[-diexp*(t - xotime)], t > xotime}}]
]


I'll plug in random variates (which can sometimes be zero based on the distribution), and evaluate this function multiple times. However, rt and pt should never be negative and should default to zero. In other words, have minimum value of zero. While the way I have it works well, the original question stemmed from the idea that this could be done more efficient with a pattern. jVincent's vanishing patterns solution works only if one argument has this pattern. If both rt and pt have this pattern, the vanishing pattern doesn't seem to work.

-
Can't you use Min[x,0] as func[x_] := (Min[x, 0] - 1)^2 + 5 ? –  b.gatessucks Feb 12 '13 at 14:14
@b.gatessucks Sure, in this situation, but I was looking for a more comprehensive solution for other conditionals (between values, integers, divisible by 71, etc...), that I can expand on later. And it would be Max in this case. –  kale Feb 12 '13 at 14:16
You're right, thanks. –  b.gatessucks Feb 12 '13 at 14:19
func[x_]=(x - 1)^2 + 5; f[x_] = Piecewise[{{func[x], x >= 0}}, func[0]] –  ssch Feb 12 '13 at 14:35
This doesn't work, since optional doesn't work like that, but if I understand you, you are looking for something like func[(_?Negative | x_: 0)] := (x - 1)^2 + 5 where x is matched as zero whenever it's negative and as it's actual match if positive? –  jVincent Feb 12 '13 at 14:37

I tried my hand at this problem before reading any of the answers and I arrived as jVincent's second solution too. You stated in a comment:

Doesn't seem to work for functions that have multiple arguments which should match these patterns though.

You should add an example of your more complicated function so that this might be addressed. Also, clarify if you mean multiple default arguments or simply multiple arguments. Here is an example of this method applied to a function with multiple arguments:

ClearAll[func]

func[x : (_?Positive | 0) : 0, ___, y_] := {x, y}

func[#, 2] & /@ {-3, 0, 5}

{{0, 2}, {0, 2}, {5, 2}}


Incidentally your specific example lends itself to a nice little trick using what I call "vanishing patterns" and the Head surrounding x:

ClearAll[func]

func[x_ | _] /; x > 0 := (x - 1)^2 + 5

func /@ {-3, 0, 5}

{6, 6, 21}


When the pattern x_ (under the Condition) does not match anything but an alternative pattern does, x in the RHS is replaced with an empty sequence. If we look at the FullForm of your RHS expression we see:

Plus[5,Power[Plus[-1,x],2]]


Therefore if x is removed it behaves the same as if x were zero.

Responding to your update here is a definition for your many-parameter function:

ClearAll[func]

func[qi_, dei_, b_, dmin_, rt : (_?Positive | 0) : 0,
pt : (_?Positive | 0) : 0, ___, t_] := {qi, dei, b, dmin, rt, pt, t}

func[1, 2, 3, 4, -3, -7, 5]

{1, 2, 3, 4, 0, 0, 5}

func[1, 2, 3, 4, 3, 7, 5]

{1, 2, 3, 4, 3, 7, 5}


Let me be clear that this is all just for fun to me and in any serious application I would likely use some variation of Szabolcs's method, e.g.:

func[qi_, dei_, b_, dmin_, rt_, pt_, t_] :=
func[{qi, dei, b, dmin, Max[0, rt], Max[0, pt], t}]

func[{qi_, dei_, b_, dmin_, rt_, pt_, t_}] := (* main def *)

-
See update for the more complicated function. rt and pt are the two values that should default to zero if the specified values are less than 0. –  kale Feb 21 '13 at 16:26
Oh, and rt and pt are used later for the Piecewise function. If the vanishing pattern is used, I don't think these conditionals work. –  kale Feb 21 '13 at 16:29
@kale I added an example to my answer, and I note of my intention. –  Mr.Wizard Feb 21 '13 at 17:13
So your last paragraph is what I was really going for: "Yes you can do this but you should do this. As far as the variation of Szabolcs's vs my Module[rt=Max[rt,0] is there any benefit to one over the other? –  kale Feb 21 '13 at 19:27
@kale Well, why didn't you say that in the first place? ;-) No, I am not aware of any method within single-definition pattern matching that is appropriate for production code. I saw this question as in interesting exploration of possible exploits. A bit later I'll add some thoughts about additional DownValues versus scoping. –  Mr.Wizard Feb 22 '13 at 0:14

I would use

f[x_?Negative] := f[0]
f[x_] := (x - 1)^2 + 5


or just Piecewise.

-
Or equivalently f[x_] := f[0];f[x_?NonNegative] := (x - 1)^2 + 5 but I think that's what the OP wants to avoid. –  sebhofer Feb 12 '13 at 15:16
@sebhofer Maybe I didn't understand the question well, I thought he wanted to avoid writing out the definition (x - 1)^2 + 5 (or a special case of it) several times. I avoided that by "redirecting" to f[0]. I know I cheated by using that fact that 0 is not negative ... –  Szabolcs Feb 12 '13 at 15:19
Maybe you're right... I was wondering the same. I thought he tried to avoid defining two distinct DownValues. Anyway +1 because that would have been my answer too. –  sebhofer Feb 12 '13 at 15:23

I'll add this as a different answer since it's quite different from my first alternative method. It seems that you can in special cases at least get by with:

func[x : (_?Positive | 0) : 0, dummy___?Negative] := (x - 1)^2 + 5


The working principle is that a dummy argument pattern is added, which matches the negative case. When supplied with a negative input, the first pattern fails, but the second will expand and match the input, letting x be set to the default.

-
Very sneaky! I like it :) –  sebhofer Feb 12 '13 at 16:25
nice!! (+1) also works without Alternatives: func[x : _?NonNegative : 0, dummy___?Negative] := (x - 1)^2 + 5? –  kguler Feb 12 '13 at 19:18
Wow. My head is spinning on this one. Doesn't seem to work for functions that have multiple arguments which should match these patterns though. Impressive, nonetheless. –  kale Feb 12 '13 at 19:27

It seems like this sort of matching isn't possible. Personally I have, at times, used a method of using Alternatives to circumvent the pattern, such that it's bound to Sequence[], and then providing the default values on the right hand side:

def[a_, ___] := a
func[(x_?Positive | _)] := (def[x, 0] - 1)^2 + 5

-