number of elements was 160 when initially developing new rtbf. This was
chosen because starting rtbf happened after re-learning xgpus
limitations. A multiple of what looks like 32 is needed (although I
remember being told it was 16) before the xgpu test program resulted an
error of zero. Using 160 was the first multiple above the ALPACA spec of
138 (although it would have been nice to be multiples of 16, so 144
could be used -- but even then it may not have performed as well). But
it became clear and an oversight on my part that 160 wouldn't work because
ALPACA uses 12 f-engines and 12 doesn't divide 160. This pushed it up to
192.

The ALPACA spec is for 80 beams. Packing more than 80 beams was looked
into when on the GBT. Geometries with beam spacing up to 96 beams was
looked at.

cublas main is no longer built

reduce build shell script to adjust

add raw and beam power mode test functions

creates weights for the swept beam pattern test of array elements as if
in a ULA. Also optionally upload from a weight file.

check outputs from each mode with plotting done for raw op mode

single program to test the operational modes of the rtbf. Allows for
benchmarking calls of the rtbf in eaach mode. Previous tests had only
looked at performance of `BEAM_OP_STI`.

was only incrementing if checking the output and so outputs were
actually being placed into the same location instead of rotating through
the host memory buffer

Handling of output stokes (polarization) parameters is now a float4
vector. This is more suitable to the information it presents.

STI outputs are now ordered differently to have the stokes values
contiguous in memory grouped by beam, then frequency, then sti time
sample output.

The rtbf host output memory is now (void*) intending to indicate to the
user the output format changes based on operational mode. The internals
handle conversion and sizing. Memory lenghts are now all bytes, except
for the input/output_offset that are not sized in bytes for convenience
to the user in doing pointer arithmetic.

added a `complex16_t` to be used with rtbf for all input data. Input
sizing is now computed uniformly using this type.

Made the output buffer in the rtbf a `void*` as part of the effort to
make more consistent the types and sizes in the input output being used.
In different modes, the output right now is always an array of floats,
but between OP_STI and OP_RAW the shape of the data is different. This
is part of perhaps using a float4 vs a complex float type like cuComplex
on the output between OP_STI and OP_RAW that a user would use to parse
data on the output.

update test scripts to use new type and make more uniform

description updates to context members, with more work still to do

update some descriptions of the context rtbf structures and how the
internal compiletime infos are calculated

This is done with a context member `input_offset` and `output_offset`
that the user must set to indicate where in the pinned host memory
arrays the RTBF should work from.

This helps for use cases like hashpipe where the host memory is a large
ring buffer and is used to buffer and move fast and long streams of data

The program used to test this was in STI mode. This has not yet been
tested for raw beam op mode, but expected to work.

Also begin to compute processing bandwidth performance