Generating a matrix using sublists A and B n times

Question

I want to write a function that generates a square matrix from sublists. My sublists are

a = Range[0, x, 0.5]; b = Range[0.25, x + 0.25, 0.5];

Suppose x=2, then I can manually evaluate {a,b,a,b,a} to generate an 5x5 matrix. I want to make the matrix automatically, of course, but without using a loop.

I've tried different ways to do it, with Nest, Range and Table, but I can't make it work.

Do I absolutely have to use a loop?

Answer 1

Since b is a+0.25, you could use Outer like this:

Outer[Plus, PadRight[{}, Length[a], {0, 0.25}], a]

You could also create the list of 0s and 0.25s using Riffle as in the other answers

(you guys are so fast! It makes iPad use a real handicap :)

Answer 2

You could do something like

mat[x_] := Module[{a = Range[0, x, .5], b = Range[.25, x + .25, .5]},
  Riffle[ConstantArray[a, x + 1], {b}]]

Then mat[2] gives

{{0., 0.5, 1., 1.5, 2.}, {0.25, 0.75, 1.25, 1.75, 2.25}, {0., 0.5, 1.,
   1.5, 2.}, {0.25, 0.75, 1.25, 1.75, 2.25}, {0., 0.5, 1., 1.5, 2.}}

Edit

Perhaps more elegant. This should also work if x isn't an integer.

mat[x_] := Module[{a = Range[0, x, .5], b = Range[.25, x + .25, .5]},
  PadRight[{}, Floor[2 x + 1], {a, b}]]

Answer 3

One possibility is this:

Riffle[
 ConstantArray[a, Ceiling[Length[a]/2]], 
 ConstantArray[b, Floor[Length[a]/2]]
]

Answer 4

Perhaps this:

x = 2;
a = Range[0, x, 0.5];
b = Range[0.25, x + 0.25, 0.5];

PadRight[#, Length@#[[1]], #] & @ {a, b}

Could also be written:

PadRight[{a,b}, Length@a, {a,b}]

---

Performance

There is a reason to use the form I proposed over that which Heike gave. If the first argument of PadRight is a packed array, and the padding list is packable (but not necessarily packed) the result will also be packed, and it is produced more quickly than if it were not packed.

foo = Range[5]; (* packed array *)

(r1 = PadRight[{},  5*^6, foo];) // RepeatedTiming
(r2 = PadRight[foo, 5*^6, foo];) // RepeatedTiming

Developer`PackedArrayQ /@ {r1, r2}
Divide @@ ByteCount /@ {r1, r2} // N

{0.047, Null}
{0.0096, Null}
{False, True}
2.99999

So using the list to pad as the seed instead of {} can result in five times better speed and three times better memory consumption.

However as Karsten 7. notes this doesn't actually help with the question example. In either case the vector elements are kept packed but the outer list is not:

Needs["Developer`"]

PackedArrayQ /@ PadRight[#,  Length@#[[1]], #] &@{a, b}
PackedArrayQ /@ PadRight[{}, Length@#[[1]], #] &@{a, b}

{True, True, True, True, True}
{True, True, True, True, True}

So while in principle it is better to pad the input list rather than {} as some cases greatly benefit from it, this case does not.

Answer 5

Here is one way without a loop:

Take[Flatten[ConstantArray[{a, b}, {Ceiling[Length[a]/2]}], 1], Length[a]]

You could also use Riffle, I guess.

Answer 6

I find using Band in a SparseArray interesting.

mat[x_] :=
 Block[{a = Range[0, x, .5],
   b = Range[.25, x + .25, .5], ln},
   ln = Length[a];
   SparseArray[Band[{1, 1}, {ln, ln}] -> {a, b}, {ln, ln}]
  ]

Answer 7

You've gotten several good answers already. Another way of doing it is to use MapIndexed as:

MapIndexed[If[EvenQ@First@#2, b, a] &, a];

This should be reasonably fast, but certainly not as fast as the PadRight answer. In the same vein, you can use related conditional constructs, Switch and Which as:

 MapIndexed[Switch[EvenQ@First@#2, True, b, False, a] &, a]; 
 MapIndexed[Which[Mod[#2, 2] == {1}, a, Mod[#2, 2] == {0}, b] &, a];

Answer 8

Or ...

Using ConstantArray:

 mat0 := Most@Flatten[#, 1] & /@ 
 ({#, .25 + #} & /@ ConstantArray[#, Ceiling[(Length@#)/2]]&@
 Range[0, #, .5] &) ;
 mat0@2.2
 (* gives *)

{{0., 0.5, 1., 1.5, 2.}, {0.25, 0.75, 1.25, 1.75, 2.25}, {0., 0.5, 1., 1.5, 2.}, {0.25, 0.75, 1.25, 1.75, 2.25}, {0., 0.5, 1., 1.5, 2.}}

Using Table:

 mat2:=Most@Flatten[#, 1] & /@ (Transpose /@ 
  Table[{#, .25 + #} & /@ #, {Ceiling[(Length@#1)/2]}] &@ Range[0, #, .5] &)

Using NestList:

 mat3:=Most@Flatten[#, 1] & /@ 
(NestList[Join, {#1, #2}, Floor[(Length@#1)/2]] & @@ {#, .25 + #} &
 @Range[0, #, .5] &)

Using Table again (less cluttered and more general):

 mat4:= Table[{#2, #1}[[1 + Mod[i, 2]]], {i, #3}] &;
 mat5 := Table[{#1, #2}[[1 + Mod[i, 2]]], {i, 0, #3 - 1}] &;
 mat4[{a, b, c, d}, {e, f, g}, 5]
 (* and  *)
 mat5[{a, b, c, d}, {e, f, g}, 5]
 (* both give *)

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

Answer 9

Let me join. This variant avoids explicit a and b initialization.

x = 2; n = 2 x + 1;
SparseArray[{
   {i_, j_} /; OddQ@i -> 0.5 (j - 1),
   {i_, j_} /; EvenQ@i -> 0.5 j - 0.25},
{n, n}] // Normal

(* ==>
    {{0, 0.5, 1., 1.5, 2.}, 
     {0.25, 0.75, 1.25, 1.75, 2.25}, 
     {0, 0.5, 1., 1.5, 2.},
     {0.25, 0.75, 1.25, 1.75, 2.25},
     {0, 0.5, 1., 1.5, 2.}} *)