Function types declarations in Mathematica

I have bumped into t开发者_运维知识库his problem several times on the type of input data declarations mathematica understands for functions.

It Seems Mathematica understands the following types declarations: _Integer, _List, _?MatrixQ, _?VectorQ

However: _Real,_Complex declarations for instance cause the function sometimes not to compute. Any idea why?

What's the general rule here?

---

When you do something like f[x_]:=Sin[x], what you are doing is defining a pattern replacement rule. If you instead say f[x_smth]:=5 (if you try both, do Clear[f] before the second example), you are really saying "wherever you see f[x], check if the head of x is smth and, if it is, replace by 5". Try, for instance,

Clear[f]
f[x_smth]:=5
f[5]
f[smth[5]]

So, to answer your question, the rule is that in f[x_hd]:=1;, hd can be anything and is matched to the head of x.

One can also have more complicated definitions, such as f[x_] := Sin[x] /; x > 12, which will match if x>12 (of course this can be made arbitrarily complicated).

Edit: I forgot about the Real part. You can certainly define Clear[f];f[x_Real]=Sin[x] and it works for eg f[12.]. But you have to keep in mind that, while Head[12.] is Real, Head[12] is Integer, so that your definition won't match.

---

Just a quick note since no one else has mentioned it. You can pattern match for multiple Heads - and this is quicker than using the conditional matching of ? or /;.

f[x:(_Integer|_Real)] := True (* function definition goes here *)

For simple functions acting on Real or Integer arguments, it runs in about 75% of the time as the similar definition

g[x_] /; Element[x, Reals] := True (* function definition goes here *)

(which as WReach pointed out, runs in 75% of the time
as g[x_?(Element[#, Reals]&)] := True).

The advantage of the latter form is that it works with Symbolic constants such as Pi - although if you want a purely numeric function, this can be fixed in the former form with the use of N.

---

The most likely problem is the input your using to test the the functions. For instance,

f[x_Complex]:= Conjugate[x]
f[x + I y]
f[3 + I 4]

returns

f[x + I y]
3 - I 4

The reason the second one works while the first one doesn't is revealed when looking at their FullForms

x + I y // FullForm == Plus[x, Times[ Complex[0,1], y]]
3 + I 4 // FullForm == Complex[3,4]

Internally, Mathematica transforms 3 + I 4 into a Complex object because each of the terms is numeric, but x + I y does not get the same treatment as x and y are Symbols. Similarly, if we define

g[x_Real] := -x

and using them

g[ 5 ]  == g[ 5 ]
g[ 5. ] == -5.

The key here is that 5 is an Integer which is not recognized as a subset of Real, but by adding the decimal point it becomes Real.

As acl pointed out, the pattern _Something means match to anything with Head === Something, and both the _Real and _Complex cases are very restrictive in what is given those Heads.