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

bring back in a simple way to read weight files and load them to the
device

simple program to write the steering vector weights that have been used
to produce beam patterns for dummy input time data that iare the angles
for the beam pattern of a ULA.

simple program to test loading those weights and use them in the same
way that the test program does

user would set the rtbf context to a weight array and then call update
weights. This was removed.

Also, initialization of the beamformer would return the device weight
memory in an indetermined state. The init now initializes the weights to
all ones [CMPLXF(1.0, 0)] and then the user is to make a call to
`update_weights` to change them. This allows the beamformer to at least
not be completely broken initially.

The update mechanics now have `update_weights` accepting an array of
float values to load to the device. The idea is that the user
creates some weights and manually update them and then they are to still
be responsible to free that memory.

simplified and improved the logic in `update_weight` to combine the
conjugate transpose into one loop instead of across multiple temporary
arrays. Two versions are left here and will follow up with a new commit
that removes the second (because I think I personally favor the first
implementation as it is more descriptive in its memory access).

this allows for the GPU to have DMA access to host memory directly