How to replace a multiple iterator Table to speed up computation

Question

I need to create an array of data which resembles to something like this

Table[{i, Sin[j^2*i]}, {j, 2000}, {i, 0., Pi, Pi/10000.}]

where each "row" of the array contains a list of tuples for varying values of the 'j' parameter. The time required for this computation can be calculated by the AbsoluteTiming function, giving

{15.1485, Null}

I succeeded in using functional programming at the first level. This speeds things up. For example, the following code does the same thing as the initial one:

Table[{#1, Sin[j^2 #1]} & /@ Range[0, Pi, Pi/10000.], {j, 2000}]

but is 5 times as fast as the original one. AbsoluteTiming returns

{3.71441, Null}

The size of these tables roughly represents the size of the data that I am currently manipulating (lots of it). Since I noticed that Table is not the most "time-efficient" option, I would like to learn how to construct this kind of table with things like pure functions and slots (which I naively assume leads to faster code).

Answer 1

Set

A=N[Range[2000]];
B=N[Range[0,Pi,Pi/10000.]];

I will compare

method1:=Outer[{#2,Sin[#1^2*#2]}&,A,B];
method2:=Transpose[{ConstantArray[B,Length[A]],
                    Sin[Outer[Times,A^2,B]]},{3,1,2}];

To check that they give the same output, run

Max[Abs[Flatten[method1-method2]]]

Timing

RepeatedTiming[method1;]
(* about 27 seconds *)

RepeatedTiming[method2;]
(* about 0.7 seconds *)

So method2 is quite a bit faster. The reason is that it uses packed arrays and certain simple constructs such as Outer[Times,...] that are fast.

Comment. Perhaps there is some room for further improvement, but I would think that one limitation is Sin. Therefore, I would be surprised if there was a solution faster than

temp=RandomReal[{-1,1},Length[A]*Length[B]];
RepeatedTiming[Sin[temp];]
(* about 0.1 seconds *)