Function argument to default under certain condition

Question

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.

Answer 1

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 *)

Answer 2

I would use

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

or just Piecewise.

Answer 3

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.

Answer 4

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