A function that accepts a pair or a list of pairs

Question

Probably a duplicate, but it's not easy to search on "lists".

I have a function that accepts a list of lists, say {{a1, b1}, {a2, b2}, {a3, b3}} and performs some computation on {ai,bi} for each i. (We may assume that none of the ai or bi are themselves lists). I would like this function to also accept simply {a1,b1} as its argument list and operate on this as if it were the only member of the (nonexistent) outer list. That is, I would like

f[{a1,b1}]

to behave the same way as

f[{{a1,b1}}]

What I have done is the following:

f[list_] := Module[{nlist},
   nlist = If [ListQ[list[[1]]], list, {list}];
   <do other stuff...>
]

This works fine, but seems pretty inelegant. Is there a better way?

Answer 1

In many circumstances it is practical and clear to do this with pattern matching.

Option 1

f[x : {{_, _} ..}] := f /@ x

f[{a_, b_}] := a^b

Now:

f[{p, q}]

p^q

f[{{a, b}, {c, d}, {e, f}}]

{a^b, c^d, e^f}

Option 2

The code above it written assuming that your function best operates on a single pair of values: the function is mapped over every pair individually. If however the function is written to more efficiently operate on the list of pairs then it would be better to consider f[{a, b}] as a special case rather than the other way around. For example:

f2[a : {{_, _} ..}] := Power @@ (a\[Transpose])
f2[x : {_, _}] := f2[{x}]

f2[{a, b}]
f2[{{a, b}, {c, d}, {e, f}}]

{a^b}

{a^b, c^d, e^f}

You could use := First @ f2[{x}] if you wish f2 to return a bare a^b in the first instance.

The second function is an order of magnitude faster on large packed arrays:

rnd = RandomReal[{1, 19}, {1500000, 2}];

f[rnd]  // Timing // First
f2[rnd] // Timing // First

1.514

0.141

Option 3

Yet another method is to use a single pattern that matches either form, using Alternatives. This method is less common, and may be less efficient than the other options, but it can be quite concise which I appreciate.

Using this the f2 function might be written like this:

f3[{a : {_, _} ..} | a : {_, _}] := Power @@ ({a}\[Transpose])

With a default configuration making this definition produces a message:

Pattern::patv: Name a used for both fixed and variable length patterns. >>

This is not an error but rather a warning that you may have made a mistake. I fairly frequently use pattern names for both fixed and variable length patterns therefore I either turn off or ignore this message.

Function is as f2 above:

f3[{a, b}]
f3[{{a, b}, {c, d}, {e, f}}]

{a^b}

{a^b, c^d, e^f}

---

A note on definition ordering

Normally multiple DownValues definitions (simple definitions with a pattern on the left side) are automatically ordered by apparent specificity. This is briefly described in the documentation page The Ordering Of Definitions. But, as stated there:

Although in many practical cases, Mathematica can recognize when one rule is more general than another, you should realize that this is not always possible. For example, if two rules both contain complicated conditions, it may not be possible to work out which is more general, and, in fact, there may not be a definite ordering. Whenever the appropriate ordering is not clear, Mathematica stores rules in the order you give them.

In the methods above Mathematica cannot decide the order of the patterns used and the definitions will be tried in the order given. It is important therefore to make the {{_, _} ..} definition first otherwise {{1, 2}, {3, 4}} would be incorrectly matched by {a_, b_}.

In the case of Option 3 patterns given in Alternatives are always matched in the order given and therefore must be ordered manually when order is important.

Answer 2

Pattern matching would be my preferred choice of implementation as well. As an alternative, observe the following:

{{{a, b}, {c, d}, {e, f}}} ~Flatten~ {1, 2}
(* {{a, b}, {c, d}, {e, f}} *)

{{a, b}} ~Flatten~ {1}
(* {{a, b}} *)

Knowing this, we can make a definition as:

f[x_] := g /@ {x} ~Flatten~ Range@ArrayDepth@x

where g is the function that does the computations on the sublists. Try it out:

f[{{a, b}, {c, d}}]
(* {g[{a, b}], g[{c, d}]} *)

f[{a, b}]
(* {g[{a, b}]} *)

f[{{a, b}}]
(* {g[{a, b}]} *)

Answer 3

Here is a short one

f[args_List] := Map[DoStuff, args, {-2}]

It works because the -2nd level is always the right one to apply the function:

f[{a1, b1}]
f[{{a1, b1}}]
f[{{a, b}, {c, d}}]
(*
Out[95]= DoStuff[{a1, b1}]

Out[96]= {DoStuff[{a1, b1}]}

Out[97]= {DoStuff[{a, b}], DoStuff[{c, d}]}
*)

Answer 4

My first thought would be to check Length[Dimensions[list]]. For example:

a = {{1, 2} {3, 4}, {5, 6}};
b = {1, 2, 3, 4, 5, 6};
Length[Dimensions[a]]
(*2*)
Length[Dimensions[b]]
(*1*)

So you could try

f[list_] := Module[{nlist},
   nlist = If [Length[Dimensions[list]]==2, list, {list}];
   <do other stuff...>
]

But it's really not much more elegant. It does have the nice advantage of working when you have a ragged list. It will, however fail if your list is something like {1, {2,3}, 4, {5,6}}. There's likely a nice method involving overloading the function for different types.

Edit: As per J.M.'s suggestion, this is equivalent to using the built-in function ArrayDepth[].

f[list_] := Module[{nlist},
   nlist = If [ArrayDepth[list]==2, list, {list}];
   <do other stuff...>
]

Answer 5

The most elegant way I see is to use:

f[list_] := Module[{},
   <do other stuff...>
]

f[list_]/;ArrayDepth[list]==1 := f[{list}]

When ArrayDepth[list] == 1, it will put it on a list.

The DownValues evaluation order goes from the more restrictive case for the more generic one.

Update:

Using J.M.'s comment, we could write it as:

 f[list_?VectorQ] := f[{list}]

Answer 6

A sloppy way:

f[v_?VectorQ] := v.{10, 1};
f[m_?MatrixQ] := f /@ m;

It is sloppy in that it matches vectors longer than an ordered pair, which would result in an error. Mr.Wizard seems to have the most precise solution so far. Here's a slight variation:

f[{a_, b_}] := 10 a + b;
f[m_] /; MatchQ[Dimensions[m], {_, 2}] := f /@ m;

Answer 7

Can it be done with a Listable function?

SetAttributes[f, Listable]

f[{x_, y_}] := {x^4, y^2}

f[{{a, b}, {c, d}, {e, g}}] // Trace

If only the attribute could be put in use after the definition?