Take the 2-minute tour ×
Mathematica Stack Exchange is a question and answer site for users of Mathematica. It's 100% free, no registration required.

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?

share|improve this question
2  
That's fine, except that I'd have done the test as If[MatrixQ[list], list, {list}]... –  J. M. Jun 9 '13 at 1:45
    
Closely related, perhaps a duplicate: (15749) –  Mr.Wizard Jun 9 '13 at 12:16
    
Another one closely related, perhaps a duplicate: Composition of mappings not working as expected –  Artes Jun 9 '13 at 12:55

7 Answers 7

up vote 18 down vote accepted

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.

share|improve this answer
    
I think this is the elegant solution. I need to get better at pattern syntax in MMA. –  Corey Kelly Jun 9 '13 at 2:02
    
Great answer. In my case, option 2 is most appropriate, but I appreciate the thought that went into producing three alternatives. –  rogerl Jun 9 '13 at 12:43
    
@rogerl Thanks, and you're welcome. –  Mr.Wizard Jun 9 '13 at 12:46
1  
@rogerl note that the order in which he placed the patterns is very important. Otherwise you might think you haven't got a bug until you happen to use a length 2 list of pairs –  Rojo Jun 9 '13 at 12:56
    
@Rojo I just realized that the note I included regarding Alternatives makes it sound like order is not important in Option 1 and Option 2 cases, when it really is. I wonder how I can write that more clearly without making this long answer longer... –  Mr.Wizard Jun 9 '13 at 13:00

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...>
]
share|improve this answer
    
Length[Dimensions[list]] is so common an operation, that in fact there is a built-in function for this: ArrayDepth[]. –  J. M. Jun 9 '13 at 1:51
    
That's great to know! Thanks. –  Corey Kelly Jun 9 '13 at 1:54

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 @0x4A4D comment, we could write it as:

 f[list_?VectorQ] := f[{list}]
share|improve this answer
    
ArrayDepth[list] == 1 is of course the same as VectorQ[list]. –  J. M. Jun 9 '13 at 2:32

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;
share|improve this answer
2  
Congratulations on hitting 10000 rep points ! –  Verbeia Jun 9 '13 at 7:23
    
@Verbeia Thank you very much! –  Michael E2 Jun 9 '13 at 13:14

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}]} *)
share|improve this answer
3  
That's a really interesting use of Flatten. –  bill s Jun 9 '13 at 3:55

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}]}
*)
share|improve this answer
1  
+1 because this can be very useful and I've used it myself. However, I passed on posting this in favor of the more explicit pattern as this can run into trouble if the expressions a1, b1 etc. are not atomic. For this reason I find this method less general and more prone to mistakes or at least the need to type check the argument, and then we're back to patterns, usually. –  Mr.Wizard Jun 9 '13 at 4:08

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?

share|improve this answer
1  
This isn't really an answer, and no, it cannot, as Listable will not stop threading at the desired level, which is why you end up with f[a] etc. –  Mr.Wizard Jun 9 '13 at 14:42

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.