I have an FFT (Fast Fourier Transform) data structure along the lines of

```
record
{
np : int(w); // number of data samples
nuf : int(w); // number of unique prime factors of 'np'
pf : [1..nuf] uint(w); // prime factors of np
rpf : [1..nuf] uint(w); // repetitiveness of pf[i]
nf : int(w); // number of factors of 'np' where np = + reduce rpf
tw : array [1..nf] of record // twiddle factors of the FFT
{
f : uint(w); // factor of concern
m : uint(w); // m is a function of f, pf, rpf, and np
v : [1..f, 1..m] real(u); // twiddle factor values
};
}
```

I have factorized `np`

in advanced. Also, courtesy of Michael, we know nuf <= 16 but that is not relevant here.

So, I know in advance, each of np, nf, nuf, and the contents of pf[..], rpf[..] and the dimensions of each 2D array `v`

within the 1D array tw, i.e. `f`

and `m`

.

For n = 280 those values of `f`

are (technically) 2, 2, 2, 5, 7.

What is the best way to allocate something like this within one routine and then return it as the result of that routine to the calling routine which itself will return the newly allocated routine to its caller. Do I know the `class`

structure at this stage - No sorry.

Thanks