Making nice code: choosing one of several procedures

Question

Happy new year mathematica gurus of stack exchange!

As I see it one of the major obstacles in getting decent at programming mathematica is that, not only do you need to learn how certain commands work, but rather that you mainly need to understand how to write your syntax. This is a typical such situation, I was hoping that someone might shine some light on how to do it.

I run this piece of code:

For[i = 1, i <= samples, i++,
 AppendTo[fList,
   f1[randomSeeds[[1 + (n - 1) (i - 1)]][[1]], 
    randomSeeds[[1 + (n - 1) (i - 1)]][[2]], 0, 0, 0, 0, 0, 0]];
 ]

For[i = 1, i <= samples, i++,
 AppendTo[fList,
   f1[randomSeeds[[1 + (n - 1) (i - 1)]][[1]], 
    randomSeeds[[1 + (n - 1) (i - 1)]][[2]], 
    randomSeeds[[2 + (n - 1) (i - 1)]][[1]], 
    randomSeeds[[2 + (n - 1) (i - 1)]][[2]], 0, 0, 0, 0]];
 ]

For[i = 1, i <= samples, i++,
 AppendTo[fList,
   f1[randomSeeds[[1 + (n - 1) (i - 1)]][[1]], 
    randomSeeds[[1 + (n - 1) (i - 1)]][[2]], 
    randomSeeds[[2 + (n - 1) (i - 1)]][[1]], 
    randomSeeds[[2 + (n - 1) (i - 1)]][[2]], 
    randomSeeds[[3 + (n - 1) (i - 1)]][[1]], 
    randomSeeds[[3 + (n - 1) (i - 1)]][[2]], 0, 0]];
 ]

For[i = 1, i <= samples, i++,
 AppendTo[fList,
   f1[randomSeeds[[1 + (n - 1) (i - 1)]][[1]], 
    randomSeeds[[1 + (n - 1) (i - 1)]][[2]], 
    randomSeeds[[2 + (n - 1) (i - 1)]][[1]], 
    randomSeeds[[2 + (n - 1) (i - 1)]][[2]], 
    randomSeeds[[3 + (n - 1) (i - 1)]][[1]], 
    randomSeeds[[3 + (n - 1) (i - 1)]][[2]], 
    randomSeeds[[4 + (n - 1) (i - 1)]][[1]], 
    randomSeeds[[4 + (n - 1) (i - 1)]][[2]]]];
 ]

As you can see most of the stuff is identical in the for loops, it's just the number of zeroes that varies in the end. In fact, I only wish to run one of these for loops at the time. Just above these for loops I specify the number of dimensions I'm working in (n in the code), for n=2 I want to run the first loop, for n=3 I want to run the second etc. At the moment I comment an uncomment the undesired parts of the code, but that seems like a very ugly solution to me.

So my question is this: is there a simple way of reducing these for copies of code into one copy? It seems to me as though this is a quite ineffective way of doing things.

Edit: Small clarification: Ideally I want something like this: I give the program "2" as input and it chooses the first for loop above etc.

Cheers, David

Answer 1

To begin with you should try to avoid explicit For loops in most cases. See Alternatives to procedural loops and iterating over lists in Mathematica. You will often also benefit from a functional rather than mutable style. Consider for example this function which does not rely on any global variables:

loop[fn_, seeds_, n_, samples_, jmax_] :=
  fn @@ PadRight[#, 8] & /@
    Join @@@ Table[seeds[[j + (n - 1) (i - 1), k]], {i, samples}, {j, jmax}, {k, 2}]

An example of use:

SeedRandom[1];
randomSeeds = RandomInteger[{-50, 50}, {99, 2}];

loop[f1, randomSeeds, 5, 8, 3]

{f1[30, -36, -50, 17, -47, 15, 0, 0],  f1[47, 18, 24, -35, -26, -46, 0, 0], 
 f1[33, 20, -49, -20, -2, -25, 0, 0],  f1[19, 6, -3, -22, 18, -24, 0, 0], 
 f1[36, 26, -7, -17, -6, 36, 0, 0],    f1[-12, -21, 25, -20, -33, 4, 0, 0], 
 f1[-44, -7, -48, 29, -33, -16, 0, 0], f1[1, -9, -35, -32, -5, -44, 0, 0]}

This matches the output of your first For loop. For the second and third:

loop[f1, randomSeeds, 5, 8, 3]

loop[f1, randomSeeds, 5, 8, 4]

I intentionally put all data upon which loop depends as arguments to avoid relying on global values. If you do not want to pass these explicitly you might rely upon Options. For example:

ClearAll[loop]

Options[loop] = {Function -> f1, "Seeds" :> randomSeeds};

loop[n_, samples_, jmax_, OptionsPattern[]] :=
  OptionValue[Function] @@ PadRight[#, 8] & /@
    Join @@@ Table[OptionValue["Seeds"][[j + (n - 1) (i - 1), k]],
      {i, samples}, {j, jmax}, {k, 2}]

This relies on the global value of randomSeeds but it is no longer hard-coded. Now the call is simpler:

loop[5, 6, 3]

{f1[30, -36, -50, 17, -47, 15, 0, 0], f1[47, 18, 24, -35, -26, -46, 0, 0], 
 f1[33, 20, -49, -20, -2, -25, 0, 0], f1[19, 6, -3, -22, 18, -24, 0, 0], 
 f1[36, 26, -7, -17, -6, 36, 0, 0],   f1[-12, -21, 25, -20, -33, 4, 0, 0]}

You change the Options at any time with SetOptions:

SetOptions[loop, Function -> foo];

loop[5, 3, 4]

{foo[30, -36, -50, 17, -47, 15, 50, -27],
 foo[47, 18, 24, -35, -26, -46, 50, 40], 
 foo[33, 20, -49, -20, -2, -25, -6, 23]}

Answer 2

I certainly agree with everything Mr. Wizard says in his answer. Taking the question at face value you can give each loop a symbol so that f[1] := For[... f[2] := For[ ... and then use Switch:

Switch[n,1,f[1],2,f[2]...]

Or as Kuba suggests:

f[n]

But that is only valid if you use f[1]...f[n]... as your symbols.