add.c:**********************************************************************
add.c: Add.c -
add.c: This program adds the elements of two real or complex vector or
add.c: matrix files together to produce a third file containg the sum.
add.c:
add.c: Options:
add.c: (no options)
add.c:
add.c: Example Usage:
add.c: add fileA fileB NewSumFile
add.c:
add.c: File Types:
add.c: In: Real or Complex, dimensionality must match.
add.c: Out: (Same type and dimension as input.)
add.c:**********************************************************************
cdotpr.c:**********************************************************************
cdotpr.c: Cdotpr.c -
cdotpr.c: This program computes the complex conjugate dot-product of two
cdotpr.c: complex vector files.
cdotpr.c:
cdotpr.c: Options:
cdotpr.c: (no options)
cdotpr.c:
cdotpr.c: Example Usage:
cdotpr.c: cdotpr fileA fileB
cdotpr.c: Dot Product = 345.7
cdotpr.c:
cdotpr.c: File Types:
cdotpr.c: In: Complex, dimensions must match.
cdotpr.c: Out: (No out file. Result goes to screen (std.out).)
cdotpr.c:**********************************************************************
cmag.c:**********************************************************************
cmag.c: Cmag.c -
cmag.c: This program converts a complex vector file into a real vector file
cmag.c: by computing the complex-magnitude of each term.
cmag.c:
cmag.c: Options:
cmag.c: (no options)
cmag.c:
cmag.c: Example Usage:
cmag.c: cmag infile newfile
cmag.c:
cmag.c: File Types:
cmag.c: In: Complex
cmag.c: Out: Real
cmag.c:**********************************************************************
conjg.c:**********************************************************************
conjg.c: Conjg.c -
conjg.c: This program conjugates a complex vector or matrix.
conjg.c:
conjg.c: Options:
conjg.c: (no options)
conjg.c:
conjg.c: Example Usage:
conjg.c: conjg infile newfile
conjg.c:
conjg.c: File Types:
conjg.c: In: Complex, Vector or Matrix
conjg.c: Out: (Same type and dimension as input file.)
conjg.c:**********************************************************************
convolve.c:**********************************************************************
convolve.c: Convolve.c -
convolve.c: This program convolves to complex or real vectors.
convolve.c: (Defaults to frequency domain convolution for efficiency.)
convolve.c:
convolve.c: Options:
convolve.c: -t - Perform Time Domain Convolution. (slower)
convolve.c: -f - Perform Frequency Domain Convolution. (default)
convolve.c:
convolve.c: Example Usage:
convolve.c: convolve infile1 infile2 outfile
convolve.c:
convolve.c: File Types:
convolve.c: In: Real or Complex Vectors (must match).
convolve.c: Out: (Same type as input files.)
convolve.c:**********************************************************************
correlate.c:**********************************************************************
correlate.c: Correlate.c -
correlate.c: This program correlates to complex or real vectors.
correlate.c: (Defaults to frequency domain convolution for efficiency.)
correlate.c:
correlate.c: Options:
correlate.c: -t - Perform Time Domain Correlation. (slower)
correlate.c: -f - Perform Frequency Domain Correlattion. (default)
correlate.c:
correlate.c: Example Usage:
correlate.c: correlate infile1 infile2 outfile
correlate.c:
correlate.c: File Types:
correlate.c: In: Real or Complex Vectors (must match).
correlate.c: Out: (Same type as input files.)
correlate.c:**********************************************************************
db.c:**********************************************************************
db.c: DB.c -
db.c: This program converts a real vector file from 'linear' to 'dB'.
db.c: For example, consider the input file to be voltage magnitudes, then
db.c: the dB are computed by taking the log of the voltage squared.
db.c: (DeciBells are considered a 'power-ratio'.) I.E. 20 Log10(x).
db.c:
db.c: A check is made for negative or excessively small input values, and
db.c: these are truncated to -150 dB.
db.c:
db.c: Options:
db.c: (no options)
db.c:
db.c: Example Usage:
db.c: db infile outfile
db.c:
db.c: Common Usage:
db.c: fft signals.dat signals.fft
db.c: cmag signals.fft spectrum.dat
db.c: db spectrum.dat spectrum.db
db.c: xgraph spectrum.db
db.c:**********************************************************************
dotpr.c:**********************************************************************
dotpr.c: Dot.c -
dotpr.c: This program computes the dot-product of two real or complex vector
dotpr.c: or matrix files.
dotpr.c:
dotpr.c: Options:
dotpr.c: (no options)
dotpr.c:
dotpr.c: Example Usage:
dotpr.c: dot fileA fileB
dotpr.c: Dot Product = 345.7
dotpr.c:
dotpr.c: File Types:
dotpr.c: In: Real or Complex, dimensions must match.
dotpr.c: Out: (No out file. Result goes to screen (std.out).)
dotpr.c:**********************************************************************
extract_imaginary.c:**********************************************************************
extract_imaginary.c: Extract_imaginary.c -
extract_imaginary.c: This program extracts the imaginary part of a complex vector file
extract_imaginary.c: to a real vector file.
extract_imaginary.c: Example: Complex value (5.6, 7.8) becomes just 7.8
extract_imaginary.c:
extract_imaginary.c: Options:
extract_imaginary.c: (no options)
extract_imaginary.c:
extract_imaginary.c: Example Usage:
extract_imaginary.c: extract_imaginary complexfile realfile
extract_imaginary.c:
extract_imaginary.c: File Types:
extract_imaginary.c: In: Complex
extract_imaginary.c: Out: Real
extract_imaginary.c:**********************************************************************
extract_real.c:**********************************************************************
extract_real.c: Extract_real.c -
extract_real.c: This program extracts the real part of a complex vector file to a
extract_real.c: real vector file.
extract_real.c: Example: Complex value (5.6, 7.8) becomes just 5.6
extract_real.c:
extract_real.c: Options:
extract_real.c: (no options)
extract_real.c:
extract_real.c: Example Usage:
extract_real.c: extract_real complexfile realfile
extract_real.c:
extract_real.c: File Types:
extract_real.c: In: Complex
extract_real.c: Out: Real
extract_real.c:**********************************************************************
fft.c:**********************************************************************
fft.c: Fft.c -
fft.c: This program reads in a complex list of data smaples, and computes
fft.c: the corresponding complex DFT, and prints this out to a file.
fft.c:
fft.c: Options:
fft.c: -f - Forward FFT
fft.c: -r - Reverse or Inverse FFT
fft.c: -i - Reverse or Inverse FFT
fft.c: -d 1 - Forward FFT
fft.c: -d -1 - Reverse FFT
fft.c:
fft.c: Example Usage:
fft.c: fft infile.dat outfile.fft
fft.c:
fft.c: File Types:
fft.c: In: Complex or Real
fft.c: Out: Complex
fft.c:**********************************************************************
fft2D.c:**********************************************************************
fft2D.c: fft2D -
fft2D.c: This program performs the 2D FFT on a complex matrix.
fft2D.c:
fft2D.c: Options:
fft2D.c: -f - Forward FFT
fft2D.c: -r - Reverse or Inverse FFT
fft2D.c: -i - Reverse or Inverse FFT
fft2D.c: -d 1 - Forward FFT
fft2D.c: -d -1 - Reverse FFT
fft2D.c:
fft2D.c: Example Usage:
fft2D.c: fft2D in_matrixfile.dat out_transformed_matrixfile.dat
fft2D.c:
fft2D.c: File Types:
fft2D.c: In: Complex or Real Matrix
fft2D.c: Out: Complex Matrix
fft2D.c:**********************************************************************
matinvert.c:**********************************************************************
matinvert.c: MatInvert.c -
matinvert.c: This program inverts a square matrix file.
matinvert.c:
matinvert.c: Options:
matinvert.c: (None.)
matinvert.c:
matinvert.c: Example Usage:
matinvert.c: matinvert in_matrixfile.dat inverted_out.dat
matinvert.c:
matinvert.c: File Types:
matinvert.c: In: Complex or Real Matrix
matinvert.c: Out: Matrix of same data-type as input matrix
matinvert.c:
matmul.c:**********************************************************************
matmul.c: Matmul.c -
matmul.c: This program multiplies a matrix by a another matrix or vector to
matmul.c: produce a new matrix file. The input files can be real or complex,
matmul.c: but must match.
matmul.c:
matmul.c: Options:
matmul.c: (no options)
matmul.c:
matmul.c: Example Usage:
matmul.c: matmul matrixfileA fileB NewMatrixFile
matmul.c:
matmul.c: File Types:
matmul.c: In: Real or Complex, dimensions must comply.
matmul.c: Out: (Same type and dimension as first input.)
matinvert.c:**********************************************************************
matXvec.c:**********************************************************************
matXvec.c: MatXvec -
matXvec.c: This program extracts a row or column from a matrix row into a
matXvec.c: vector.
matXvec.c:
matXvec.c: Options:
matXvec.c: -row x - Row to extract.
matXvec.c: -col x - column to extract.
matXvec.c: Note: Rows and columns assumed to range 1 to n.
matXvec.c: One (1) is the first row or column.
matXvec.c: The last row or column is n, where n is the number of rows
matXvec.c: or columns, respectively.
matXvec.c:
matXvec.c: Example Usage:
matXvec.c: matXvec in_matrixfile.dat -row 3 out_vector.dat
matXvec.c:
matXvec.c: File Types:
matXvec.c: In: Complex or Real Matrix
matXvec.c: Out: Vector of same data-type as input matrix
matXvec.c:**********************************************************************
multpbp.c:**********************************************************************
multpbp.c: Multpbp.c -
multpbp.c: This program multiplies a vector by another vector, point-by-point.
multpbp.c: The input files can be real or complex, but must match.
multpbp.c:
multpbp.c: Options:
multpbp.c: (no options)
multpbp.c:
multpbp.c: Example Usage:
multpbp.c: multpbp fileA fileB File.new
multpbp.c:
multpbp.c: File Types:
multpbp.c: In: Real or Complex, dimensions must match.
multpbp.c: Out: (Same type and dimension as input files.)
multpbp.c:**********************************************************************
normalize.c:**********************************************************************
normalize.c: Normalize.c -
normalize.c: This program normalizes a real or complex vector. In other words,
normalize.c: it first scans the vector to determine the sum of the magnitudes
normalize.c: of the elements, and then scales the vector, such that the sum of
normalize.c: the magnitudes equals 1.0.
normalize.c:
normalize.c: Options:
normalize.c: -bymax - Changes normalization to be based on the magnitude of
normalize.c: the maximum element, instead of the sum of the
normalize.c: magnitudes.
normalize.c:
normalize.c: Example Usage:
normalize.c: normalize oldfile newfile
normalize.c:
normalize.c: File Types:
normalize.c: In: Real or Complex
normalize.c: Out: (Same type as input.)
normalize.c:**********************************************************************
outpr.c:**********************************************************************
outpr.c: Outpr.c -
outpr.c: This program multiplies to vectors to produce a matrix by outer
outpr.c: product multiply. The input files can be real or complex, but
outpr.c: types must match.
outpr.c:
outpr.c: Options:
outpr.c: (no options)
outpr.c:
outpr.c: Example Usage:
outpr.c: outpr VecA VecB NewMatrixFile
outpr.c:
outpr.c: File Types:
outpr.c: In: Real or Complex, dimensions and types must match.
outpr.c: Out: (Same type and dimension as first input.)
outpr.c:**********************************************************************
phase.c:**********************************************************************
phase.c: Phase.c -
phase.c: This program converts a complex vector file into a real vector file
phase.c: containing phase, in degrees, of each term.
phase.c:
phase.c: Options:
phase.c: -radians - Report phase in radians instead of degrees.
phase.c:
phase.c: Example Usage:
phase.c: phase complexfile newfile
phase.c:
phase.c: File Types:
phase.c: In: Complex
phase.c: Out: Real
phase.c:**********************************************************************
rand_gen.c:**************************************************************
rand_gen.c: Rand_Gen - This utility produces a random vector file.
rand_gen.c:
rand_gen.c: Command line options:
rand_gen.c: {file_name} - Output file name.
rand_gen.c: -n - Number of samples to produce.
rand_gen.c: -seed - Random Seed to use.
rand_gen.c: -realvec - Produce an indexed real-vector file.
rand_gen.c:
rand_gen.c: Specify values on command line, or be prompted for them.
rand_gen.c:
rand_gen.c: By default, this utility produces a complex vector, one
rand_gen.c: real-imaginary pair per line. By using the -realvec option,
rand_gen.c: rand_gen produces an indexed real-vector file, having the
rand_gen.c: integer count of the sample and a real sample on each line.
rand_gen.c: (The realvec version is directly plotted with xgraph.
rand_gen.c: The default complex version requires the -a option in
rand_gen.c: xgraph, for automatic x-axis increment, for plotting.)
rand_gen.c:
rand_gen.c: Example:
rand_gen.c: rand_gen -n 100 -seed 405690 noise.dat
rand_gen.c: xgraph -a noise.dat
rand_gen.c: Or,
rand_gen.c: sin_gen -n 100 -seed 405690 -realvec noise.dat
rand_gen.c: xgraph noise.dat
rand_gen.c:
rand_gen.c: File Types:
rand_gen.c: In: (none)
rand_gen.c: Out: Complex (default), or Real (option)
rand_gen.c:**************************************************************
real2cmplx.c:**********************************************************************
real2cmplx.c: real2cmplx.c -
real2cmplx.c: This program converts a real vector file to a complex vector file.
real2cmplx.c: Example: Real value 7.8 is converted to (7.8, 0.0) complex.
real2cmplx.c:
real2cmplx.c: Options:
real2cmplx.c: (no options)
real2cmplx.c:
real2cmplx.c: Example Usage:
real2cmplx.c: real2cmplx infile newfile
real2cmplx.c:
real2cmplx.c: File Types:
real2cmplx.c: In: Real
real2cmplx.c: Out: Complex
real2cmplx.c:**********************************************************************
scale.c:**********************************************************************
scale.c: Scale.c -
scale.c: This program scales a real or complex vector or matrix file by a
scale.c: real or complex scalar, respectively.
scale.c:
scale.c: Options:
scale.c: -s Scale factor
scale.c: If input file is real, than scale factor must be real.
scale.c: If input file is complex, than scale factor must be complex.
scale.c: -x For Real-Vectors only, scale the x-values (index) instead
scale.c: of the y-values, which otherwise is assumed the default.
scale.c:
scale.c: Example Usage:
scale.c: Scale a real file by real value 4.0. Send results to new file.
scale.c: scale -s 4.0 oldfile newfile
scale.c:
scale.c: Scale complex file by (3.8, 2.4). Send results to new file.
scale.c: scale -s 3.8 2.4 oldfile newfile
scale.c:
scale.c: File Types:
scale.c: In: Real or Complex, Vector or Matrix.
scale.c: Out: (Same type as input.)
scale.c:**********************************************************************
shift.c:**********************************************************************
shift.c: Shift.c -
shift.c: This program shifts a real or complex vector or matrix file by a
shift.c: real or complex scalar, respectively. In other words, it ADDs
shift.c: an "offset" value to each term.
shift.c:
shift.c: Options:
shift.c: -s Shift factor
shift.c: If input file is real, than shift factor must be real.
shift.c: If input file is complex, than shift factor must be complex.
shift.c: -x For Real-Vectors only, shift the x-values (index) instead
shift.c: of the y-values, which otherwise is assumed the default.
shift.c:
shift.c: Example Usage:
shift.c: Shift a real file by real value 4.0. Send results to new file.
shift.c: shift -s 4.0 oldfile newfile
shift.c:
shift.c: Shift complex file by (3.8, 2.4). Send results to new file.
shift.c: shift -s 3.8 2.4 oldfile newfile
shift.c:
shift.c: File Types:
shift.c: In: Real or Complex, Vector or Matrix
shift.c: Out: (Same type as input.)
shift.c:**********************************************************************
sine_gen.c:**************************************************************
sine_gen.c: Sine_Gen - This utility produces a sinusoidal vector file.
sine_gen.c:
sine_gen.c: Command line options:
sine_gen.c: {file_name} - Output file name.
sine_gen.c: -n - Number of samples to produce.
sine_gen.c: -freq - Frequency, or number of cycles in the
sine_gen.c: produced vector.
sine_gen.c: -realvec - Produce an indexed real-vector file.
sine_gen.c:
sine_gen.c: Specify values on command line, or be prompted for them.
sine_gen.c:
sine_gen.c: By default, this utility produces a complex vector, one
sine_gen.c: real-imaginary pair per line. By using the -realvec option,
sine_gen.c: sine_gen produces an indexed real-vector file, having the
sine_gen.c: integer count of the sample and a real sample on each line.
sine_gen.c: (The realvec version is directly plotted with xgraph.
sine_gen.c: The default complex version requires the -a option in
sine_gen.c: xgraph, for automatic x-axis increment, for plotting.)
sine_gen.c:
sine_gen.c: Example:
sine_gen.c: sine_gen -n 100 -freq 5 sinewave.dat
sine_gen.c: xgraph -a sinewave.dat
sine_gen.c: Or,
sine_gen.c: sin_gen -n 100 -freq 5 -realvec sinewave.dat
sine_gen.c: xgraph sinewave.dat
sine_gen.c:
sine_gen.c: File Types:
sine_gen.c: In: (none)
sine_gen.c: Out: Complex (default), or Real (option)
sine_gen.c:**************************************************************
statistics.c:**********************************************************************
statistics.c: Statistics.c -
statistics.c: This program Computes mean, variance, min, max, and optionally the
statistics.c: median, of a real vector.
statistics.c:
statistics.c: Options:
statistics.c: -median - Find the median (requires sufficient memory).
statistics.c:
statistics.c: Example Usage:
statistics.c: statistics vectorfile
statistics.c: Or,
statistics.c: statistics -median vectorfile
statistics.c:
statistics.c: File Types:
statistics.c: In: Real Vector.
statistics.c: Out: (None. Reports result to std.out (screen).)
statistics.c:**********************************************************************
sub.c:**********************************************************************
sub.c: Sub.c -
sub.c: This program subtracts the elements of one real or complex vector
sub.c: or matrix file from another to produce a third file containg the
sub.c: differences.
sub.c:
sub.c: Options:
sub.c: (no options)
sub.c:
sub.c: Example Usage:
sub.c: sub fileA fileB resultFile
sub.c:
sub.c: File Types:
sub.c: In: Real or Complex, dimensionality must match.
sub.c: Out: (Same type and dimension as input.)
sub.c:**********************************************************************
transpose.c:**********************************************************************
transpose.c: Transpose.c -
transpose.c: This program transposes a real matrix, or conjugate transposes a
transpose.c: complex matrix.
transpose.c:
transpose.c: Options:
transpose.c: (no options)
transpose.c:
transpose.c: Example Usage:
transpose.c: transpose in_matrixfile.dat out_transposed_matrixfile.dat
transpose.c:
transpose.c: File Types:
transpose.c: In: Complex, Vector or Matrix
transpose.c: Out: (Same type and dimension as input file.)
transpose.c:**********************************************************************
ucirc.c:**********************************************************************
ucirc.c: Ucirc.c -
ucirc.c: This program draws the unit-circle.
ucirc.c:
ucirc.c: Options:
ucirc.c: (no options)
ucirc.c:
ucirc.c: Example Usage:
ucirc.c: ucirc ucirc.dat
ucirc.c: xgraph ucirc.dat
ucirc.c:
ucirc.c: File Types:
ucirc.c: In: (None.)
ucirc.c: Out: (xy plot file.)
ucirc.c:**********************************************************************
window.c:**********************************************************************
window.c: Window.c -
window.c: This program produces windowing functions, also called amplitude
window.c: shadings or tapers. Used to minimize the effects of
window.c: discontinuities at the ends of sample records.
window.c: Defaults to Hamming window, but produces other windows by options.
window.c:
window.c: Options:
window.c: -n x - Number of points. (Default = 128)
window.c: -bartlet - Produce bartlet or basic trianglur window.
window.c: -triangular - Produce basic trianglur window.
window.c: -hanning - Produce cosine squared window.
window.c: -hamming - Produce Hamming window (default).
window.c: Also called "raised-cosine".
window.c: -blackman - Produce Blackman window.
window.c:
window.c: Example Usage:
window.c: window window.dat
window.c:
window.c: File Types:
window.c: In: (None.)
window.c: Out: (Real vector file.)
window.c:**********************************************************************
zfill.c:**********************************************************************
zfill.c: Zfill.c -
zfill.c: This program appends a real or complex vector with zeros.
zfill.c:
zfill.c: Options:
zfill.c: Use:
zfill.c: -l length - Length to make the new vector.
zfill.c: Or,
zfill.c: -nz number - Number of zeros to add.
zfill.c:
zfill.c: Example Usage:
zfill.c: zfill -l 512 oldfile newfile
zfill.c:
zfill.c: File Types:
zfill.c: In: Real or Complex, Vector.
zfill.c: Out: (Same type as input.)
zfill.c:**********************************************************************
mdeterm.c:**********************************************************************
mdeterm.c: Mdeterm.c -
mdeterm.c: This program computes the determinant of a matrix.
mdeterm.c:
mdeterm.c: Options:
mdeterm.c: (None.)
mdeterm.c:
mdeterm.c: Example Usage:
mdeterm.c: mdeterm in_matrixfile.dat
mdeterm.c:
mdeterm.c: File Types:
mdeterm.c: In: Complex or Real Matrix
mdeterm.c: Out: (Reports determinant to screen.)
mdeterm.c:**********************************************************************
mat2image.c:**********************************************************************
mat2image.c: Mat2image.c -
mat2image.c: This program converts a matrix to an image file.
mat2image.c: Image file is gray-scale intensity image of real matrix values or
mat2image.c: magintude of complex matrix values.
mat2image.c:
mat2image.c: Options:
mat2image.c: -ascii - Produce ascii ppm image file.
mat2image.c: -brightness - Normal=0.0, darker<0.0, brighter>0.0.
mat2image.c: -contrast - Normal=1.0, duller<1.0, more contrast>1.0.
mat2image.c: -color - Produce color (rainbow/temperature) image.
mat2image.c:
mat2image.c: Example Usage:
mat2image.c: mat2image in_matrixfile.dat out_image.ppm
mat2image.c:
mat2image.c: File Types:
mat2image.c: In: Complex or Real Matrix
mat2image.c: Out: Binary ppm image file.
mat2image.c:**********************************************************************
augmatvec.c:**********************************************************************
augmatvec.c: Mataugv -
augmatvec.c: This program augments a matrix by a vector. In other words, it
augmatvec.c: adds a row or column to a matrix from a vector file.
augmatvec.c: The dimensions of the matrix length or height must match the vector
augmatvec.c: length.
augmatvec.c:
augmatvec.c: Options:
augmatvec.c: -r - Add row to matrix, last row.
augmatvec.c: -c - Add column to matrix, last column.
augmatvec.c: -row x - Add xth row to matrix.
augmatvec.c: -col x - Add xth column to matrix.
augmatvec.c: Note: Rows and columns assumed to range 1 to n.
augmatvec.c: One (1) is the first row or column.
augmatvec.c: The last row or column is n, where n is the number of rows
augmatvec.c: or columns, respectively.
augmatvec.c:
augmatvec.c: Example Usage:
augmatvec.c: mataugv mat.dat vec.dat -row 3 out_mat.dat
augmatvec.c:
augmatvec.c: File Types:
augmatvec.c: In: Complex or Real Matrix
augmatvec.c: Out: Vector of same data-type as input matrix
augmatvec.c:**********************************************************************
join2xy.c:**********************************************************************
join2xy.c: Join2xy.c -
join2xy.c: This program joins 2 Real Vector files into one Real Vector file,
join2xy.c: where the first input file becomes the x value, and the second, the
join2xy.c: y value of the output file.
join2xy.c: Both files should be of equal length.
join2xy.c:
join2xy.c: Options:
join2xy.c: (no options)
join2xy.c:
join2xy.c: Example Usage:
join2xy.c: join2xy fileA fileB fileC
join2xy.c: xgraph fileC
join2xy.c: Assuming fileA was:
join2xy.c: 1 400
join2xy.c: 2 500
join2xy.c: 3 600
join2xy.c: And fileB was:
join2xy.c: 1 8
join2xy.c: 2 9
join2xy.c: 3 10
join2xy.c: Then fileC would be:
join2xy.c: 400 8
join2xy.c: 500 9
join2xy.c: 600 10
join2xy.c:
join2xy.c: File Types:
join2xy.c: In: Real.
join2xy.c: Out: Real.
join2xy.c:
join2xy.c:***********************************************************************
histogram.c:**********************************************************************
histogram.c: Histogram.c -
histogram.c: This program plots the histogram of a real vector.
histogram.c:
histogram.c: Options:
histogram.c: -nbins x - Number of bins to divide histogram of values into.
histogram.c:
histogram.c: Example Usage:
histogram.c: histogram vectorfile histo.dat
histogram.c: xgraph histo.dat
histogram.c:
histogram.c: File Types:
histogram.c: In: Real Vector.
histogram.c: Out: histgram.dat (plot-file)
histogram.c:**********************************************************************
barchart.c:**********************************************************************
barchart.c: BarChart.c -
barchart.c: This program converts a real vector file into a bar-chart graph for
barchart.c: viewing with xgraph.
barchart.c:
barchart.c: Options:
barchart.c: -thickness
barchart.c: (By default, barchart sets the bar thickness based on the
barchart.c: number of points in your file. This option lets you override
barchart.c: the automatic setting. 1.0 is thin, 10-is thicker, etc..)
barchart.c: -title (title)
barchart.c: -xtitle (x_axis_title>
barchart.c: -ytitle (y_axis_title>
barchart.c: Note: Quotes are needed around multi-word titles.
barchart.c:
barchart.c: Example Usage:
barchart.c: barchart infile graphfile
barchart.c: xgraph graphfile
barchart.c:
barchart.c: File Types:
barchart.c: In: Real
barchart.c: Out: [graph-format]
barchart.c:**********************************************************************
differentiate.c:**********************************************************************
differentiate.c: Differentiate.c -
differentiate.c: This program differentiates the values in a real vector file.
differentiate.c: It produces another vector file, which is the "differential", or
differentiate.c: the sample-to-sample differences.
differentiate.c:
differentiate.c: Options:
differentiate.c: (No options.)
differentiate.c:
differentiate.c: Example Usage:
differentiate.c: differentiate infile outfile
differentiate.c:
differentiate.c: File Types:
differentiate.c: In: Real
differentiate.c: Out: Real
differentiate.c:**********************************************************************
integrate.c:**********************************************************************
integrate.c: Integrate.c -
integrate.c: This program integrates the values in a real vector file.
integrate.c: It produces another vector file, which is the "running-sum".
integrate.c:
integrate.c: Options:
integrate.c: (No options.)
integrate.c:
integrate.c: Example Usage:
integrate.c: integrate infile outfile
integrate.c:
integrate.c: File Types:
integrate.c: In: Real
integrate.c: Out: Real
integrate.c:**********************************************************************
nums2vec.c:/***********************************************************************
nums2vec.c:/* nums2vec.c -
nums2vec.c:/* This program converts a simple list of numbers, such as from Matlab
nums2vec.c:/* to NumUtils Real Vector format, by adding the header line and an
nums2vec.c:/* index column.
nums2vec.c:/*
nums2vec.c:/* Options:
nums2vec.c:/* Use:
nums2vec.c:/* -c - Make a complex vector instead of a real vector.
nums2vec.c:/* -i - Expect index on each line of file. ie. x y
nums2vec.c:/* (one x-y pair per line)
nums2vec.c:/*
nums2vec.c:/* Example Usage:
nums2vec.c:/* nums2vec oldfile newfile
nums2vec.c:/*
nums2vec.c:/* File Types:
nums2vec.c:/* In: (textual list of numbers)
nums2vec.c:/* Out: Real or complex Vector.
nums2vec.c:/***********************************************************************
vec2nums.c:/************************************************************************
vec2nums.c:/* vec2nums.c -
vec2nums.c:/* This program converts real or complex vector files to simple number
vec2nums.c:/* list files, such as used by Matlab, by removing the header line and
vec2nums.c:/* index column.
vec2nums.c:/*
vec2nums.c:/* Example Usage:
vec2nums.c:/* vec2nums vecfile newfile
vec2nums.c:/*
vec2nums.c:/* File Types:
vec2nums.c:/* In: Real or complex Vector.
vec2nums.c:/* Out: (textual list of numbers)
vec2nums.c:/************************************************************************
enter_vec.c:/************************************************************************
enter_vec.c:/* enter_vec.c -
enter_vec.c:/* This program creates a new vector or matrix file, by asking a series
enter_vec.c:/* of questions. You enter numbers at your keyboard in response to the
enter_vec.c:/* interactive prompts.
enter_vec.c:/*
enter_vec.c:/* Example Usage:
enter_vec.c:/* entervec newfile
enter_vec.c:/*
enter_vec.c:/* File Types:
enter_vec.c:/* Out: Real or complex Vector or Matrix.
enter_vec.c:/************************************************************************
identity_matrix.c:/****************************************************************/
identity_matrix.c:/* Identity_Matrix - This utility produces an identity martix. */
identity_matrix.c:/* A square matrix having all ones down the main diagonal, and */
identity_matrix.c:/* zeros off diagonal. */
identity_matrix.c:/* */
identity_matrix.c:/* Command line options: */
identity_matrix.c:/* {file_name} - Output file name. */
identity_matrix.c:/* -n kk - Create matrix of dimension kk. */
identity_matrix.c:/* -complex - Produce a complex matrix. */
identity_matrix.c:/* -scale xx - Main diagonal will have value xx */
identity_matrix.c:/* instead of 1.0. */
identity_matrix.c:/* -sizeofmat matname - Create matrix of dimension */
identity_matrix.c:/* matching that of the one in file 'matname'. */
identity_matrix.c:/* */
identity_matrix.c:/* By default, this utility produces a real matrix of dimension */
identity_matrix.c:/* 3x3, unless otherwise specified. */
identity_matrix.c:/* */
identity_matrix.c:/* File Types: */
identity_matrix.c:/* Out: Real (default), or Complex (option) */
identity_matrix.c:/****************************************************************/
abs.c:/**********************************************************************
abs.c:/* Abs.c -
abs.c:/* This program takes the absolute values of a real vector file.
abs.c:/* It makes any negative values positive.
abs.c:/* If the input file is complex, it takes the complex magnitudes.
abs.c:/*
abs.c:/* Options:
abs.c:/* -x - Take absolute value of the abscissa (x-value) instead of
abs.c:/* ordinate (y-value).
abs.c:/*
abs.c:/* Example Usage:
abs.c:/* abs infile newfile
abs.c:/*
abs.c:/* File Types:
abs.c:/* In: Real or Complex
abs.c:/* Out: Real
abs.c:/**********************************************************************
image2matrix.c:/************************************************************************
image2matrix.c:/* Image2matrix.c -
image2matrix.c:/* This program converts an image file to a NumUtils matrix file.
image2matrix.c:/* By default, the image's intensity values become the matrix values.
image2matrix.c:/* The output values span 0.0 to 1.0. Maximum intensity (brightest)
image2matrix.c:/* equals 1.0. Mimumum intensity (darkest) equals 0.
image2matrix.c:/* Options enable selecting conversion for either red, blue, or green
image2matrix.c:/* (rgb) component colors to matrix values.
image2matrix.c:/*
image2matrix.c:/* Options:
image2matrix.c:/* -red - Select the red-component of the image to matrix.
image2matrix.c:/* -blue - Select the blue-component of the image to matrix.
image2matrix.c:/* -green - Select the green-component of the image to matrix.
image2matrix.c:/*
image2matrix.c:/* Example Usage:
image2matrix.c:/* image2matrix in_imagefile.ppm out_matrix.dat
image2matrix.c:/*
image2matrix.c:/* File Types:
image2matrix.c:/* In: PPM image file.
image2matrix.c:/* Out: Real Matrix file.
image2matrix.c:/************************************************************************
decimate.c:/************************************************************************
decimate.c:/* Decimate.c -
decimate.c:/* This program decimates a real or complex vector by the decimation
decimate.c:/* amount, k. It reads one input file (having n items) to produce an
decimate.c:/* output file containing n/k points. I.E. It copies each kth sample
decimate.c:/* to the output file. This is useful for reducing the number of
decimate.c:/* points in a vector, usually after low-pass filtering.
decimate.c:/* This operation is also called "down-sampling", or "sub-sampling".
decimate.c:/* Default decimation amount is 2. I.E. Every other sample (all even
decimate.c:/* samples, starting with sample zero).
decimate.c:/* Writes the (i mod k) = 0 samples, from samples numbered 0 : n-1.
decimate.c:/*
decimate.c:/* Options:
decimate.c:/* -k = Decimation amount (default=2).
decimate.c:/* -offset = Offset value ((i mod k) = offset), default=0.
decimate.c:/*
decimate.c:/* Example Usage:
decimate.c:/* Decimate file_in -k 4 File_out
decimate.c:/*
decimate.c:/* File Types:
decimate.c:/* In: Real or Complex.
decimate.c:/* Out: (Same type and dimension as input.)
decimate.c:/************************************************************************
(Questions, Comments, & Suggestions: xgraphadmin@xgraph.org)