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.

There are some other questions on this topic but I could not get an answer from reading them. What I want to do is use Apply on some of the arguments of a function, h, and then Map on another argument. Here is what I attempted:

Map[Apply[{h[#, ##]} &, {a, b}] &, {1, 2}]
(* ===>{{h[a, a, b]}, {h[a, a, b]}} *)

The elements I want to Map over never get used. But this is not what I want. I want just

{h[1,a,b],h[2,a,b]}

I could use Table instead of Map but it's slow (slower than just using Apply twice) and I was hoping Map would be faster.

I understand that Apply is using both # and ## but I'm not sure what syntax is correct to force the first Slot to be used by Map instead of Apply.

EDIT: This is more like what I actually want to do:

Map[Apply[{h1[#, ##],h2[#, ##]} &, {RandomReal[], RandomReal[]}] &, {1, 2}]

So I want output as

{{h1[1, a1,b1], h2[1, a1,b1]},{h1[2, a2,b2], h2[2, a2,b2]}}

where I a's and b's are the random numbers. So to get this, I think the order of Apply and Map is important.

share|improve this question

2 Answers 2

up vote 5 down vote accepted

One option is to separate the slots by using an explicit Function for the second argument

Map[Function[arg, Apply[{h[arg, ##]} &, {a, b}]], {1, 2}]

Regarding your updated question. The approach is the same

Map[Function[arg, Apply[{h1[arg, ##], h2[arg, ##]} &, 
  {RandomReal[], RandomReal[]}]], {1, 2}]
share|improve this answer

Simply you could use:

Thread @ h[{1, 2}, a, b]
{h[1, a, b], h[2, a, b]}

If you can demonstrate how that fails in your application I will give other methods.


It was suggested that I use Sequence @@ {a, b} so as to keep {a, b} in the given form. I did not, because I was not clear as to the expected input format and because I felt that it would obscure the syntax.

Taking a guess as to your desired syntax, you might use:

f[head_][{q__}, {r__}] := Thread @ Unevaluated @ head[{q}, r]

f[h][{1, 2}, {a, b}]
{h[1, a, b], h[2, a, b]}

Unevaluated is needed for cases such as:

f[Print][{1, 2}, {a, b}];

1ab

2ab


Based on your updated question perhaps you want:

Through[{h1, h2} @@ RandomReal[1, 2] ~Prepend~ #] & /@ {1, 2}

Or

Through[{h1, h2}[#, Sequence @@ RandomReal[1, 2]]] & /@ {1, 2}

But if this is really representative of your usage there is probably a faster way.

share|improve this answer
1  
Maybe use Sequence @@ {a, b} to preserve the input in the given form ? –  b.gatessucks Dec 12 '12 at 16:56
    
@b.gatessucks I'm still not sure what is the input. Is it supposed to be the two expression {1, 2} and {a, b}? –  Mr.Wizard Dec 12 '12 at 17:00

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.