SPUC Namespace Reference


Classes

class  a_d
 An A/D conversion class. More...
class  agc
 This is a simple sigma-delta type AGC for the variable rate QPSK example. More...
class  allpass
 Template Class for allpass filter consisting of several stages of 1st order allpass sections. More...
class  allpass_1
 Template class for 1st order allpass filter with programmble gain and delay. More...
class  allpass_1aq1
 The filter is a "first-order" Allpass section. More...
class  allpass_1aq2
 The filter is a "first-order" Allpass section. More...
class  allpass_2nd
 Template for 2nd order allpass filter. More...
class  array
 General array class. More...
class  base_demod
 base class for a demodulator (not currently used?) More...
class  base_type
 Determine base class for complex, builtin, sint, etc, classes. More...
class  base_type< complex< T > >
class  base_type< builtin< T > >
class  baud_eq_env
 Class for doing a simulation of an equalizer running at 1 sample/symbol. More...
class  bit
class  bit_scrambler
 Data scrambler. More...
class  bpe
 Block Phase Estimator. More...
class  bpsk_ber_test
 A Class for simulating a BPSK system. More...
class  builtin
 Wrapper around built-in types to allow custom manipulations. More...
class  carrier_nco
 A specialization example of a sin/cosine look-up NCO. More...
class  cfft
class  cic
 class for CIC digital filter More...
class  circ_buffer
 Circular Buffer. More...
class  complex
 Spuc template complex class. More...
class  conjr
class  conjr< complex< T > >
class  convolutional_interleaver
class  cordic
 Cordic rotator. More...
class  cutboost
 IIR structure that can cut or boost signals at a programmed frequency. More...
class  data_conv_encoder
 Convolutional encoder for punctured encoding. More...
class  delay
 Template class for Delay line. More...
class  dqpsk
 Differential QPSK encoder/decoder. More...
class  dvb_conv_encoder
 DVB Convolution encode for rate 1/2. More...
class  fading_channel
class  farrow
 Template Class for Farrow implementation of a ploynomial interpolation using a FIR filter. More...
class  farrow_upsampler
 Upsampler/interpolator using farrow structure. More...
class  fbool_nco
 Template class for a NCO based on template unsigned int class. More...
class  fir
 Template Class for Modeling a Finite Impulse Response filter. More...
class  fir_adapt
 template class fir_adapt Based on FIR class, created to support LMS adaptive filtering More...
class  fir_coeff
 Template Class for Modeling a Finite Impulse Response filter. More...
class  fir_decim
 template class for fir decimation based on FIR class More...
class  fir_interp
 template class fir_decim based on FIR class More...
class  fnco
 Template class for a NCO based on template unsigned int class. More...
class  fundtype
 Determine fundamental type when using builtin template. More...
class  fundtype< builtin< T > >
class  iir
 Tempate Class for iir filter. More...
class  iir_1st
 Template Class for 1st Order iir filter. More...
class  iir_2nd
 Template for 2nd Order IIR filter. More...
class  iir_allpass1
 Template Class for IIR Filter using 2 1st order sections. More...
class  iir_allpass1_cascade
 Template Class for iir filter consisting of 1st order allpass sections. More...
class  iir_allpass1_halfband
 Template Class for Allpass halfband IIR Filter. More...
class  iir_allpass2
 Template Class for IIR filter using sum of 2nd Order Allpass sections. More...
class  iir_coeff
 Class for iir filter design. More...
class  iir_comb
 Template for IIR comb type filter with programmable delay and gain. More...
class  iir_delay_allpass1
 Template Class for IIR filter consisting of 2 1st Order Allpass sections. More...
class  iir_df
 Template Class for Modeling a Direct Form IIR. More...
class  iir_exp1
 Template Class for 1st Order lowpass iir filter. More...
class  iir_hpf
 Template Class for 1st Order high pass IIR filter from S-domain transformation. More...
class  iir_hpf1
 Template Class for 1st Order High-pass iir filter. More...
class  iir_lpf
class  iir_lpf1
 Template Class for 1st Order lowpass iir filter. More...
class  iir_shelf
class  lagrange
 Template Lagrange interpolation via FIR Fitler. More...
class  lms_dfe
 Template Class for LMS Decision Feedback equalizer. More...
class  loop_filter
 Loop Filter for use in PLL circuits. More...
class  magsqr
class  magsqr< complex< T > >
class  matrix
class  max_pn
 Maximal Length Pseudorandom sequence generator. More...
class  mixed_type
 Determine resultant type when mixing two types in math operations. More...
class  mle
 A Configurable Maximum Likelihood Sequence Estimator Class. More...
class  nco
 NCO with 32 bit accumulator. More...
class  noise
 Gaussian noise routine. More...
class  notch_allpass
 IIR notch filter based on 2nd order allpass structure. More...
class  notch_iir
 IIR notch filter based on 2nd order biquad. More...
class  ofdm_data_encoder
 OFDM/802.11A/G Data Encoder. More...
class  qam_conv_decoder
 QAM convolutional decoder. More...
class  qam_mod
 QAM Modulator for BPSK - 64 QAM for 802.11A Data modulation. More...
class  qam_tx
 Class for QAM transmitter using a root raised cosine transmit filter. More...
class  qnoise
 class to add quantization noise to signal More...
class  qnoise< complex< T > >
class  qpsk
 A QPSK receiver that can operate at exactly 2 samples/symbol. More...
class  qpsk_ber_test
 A Class for doing BER test on QPSK. More...
class  qpsk_discriminators
 A Class incorporating several symbol and carrier discriminators for QPSK. More...
class  qpsk_variable
 A QPSK receiver that can operate over a range of non-integer sampling rates. More...
class  quad_data
 Class for QPSK data using a root raised cosine transmit filter. More...
class  quantiser
 ........ More...
class  quantized_type
 Determine quantized version of particular type, i.e complex<double> -> complex<long>, etc. More...
class  quantized_type< complex< T > >
class  quantizer
class  quantizer< complex< T > >
class  remez_fir
 template Remez_fir class More...
class  resampler
 A resampling block using interpolator, halfband filter and NCO. More...
class  rls
 Recursive Least Squares Algorithm. More...
class  rounder
class  rounder< complex< T > >
class  running_sum
 template class running average filter consisting of a delay line, adder and subtractor More...
class  rv_stat
 a basic random Variable Statistics Class More...
class  saturater
class  saturater< complex< T > >
class  scic
 Implementation for sharped cascaded integrator comb filter. More...
class  sigma_delta
 Simple 1st order All-digital Sigma Delta converter. More...
class  signbitr
class  signbitr< complex< T > >
class  sim_qam
 A Class for simulating a QAM system. More...
class  sim_qpsk
 A Class for simulating a QPSK system that includes. More...
class  sim_qpsk_variable
 A Class for simulating a variable rate QPSK system. More...
class  smart_array
class  sum_and_dump
 sum and dump filter More...
class  timing_nco
 A NCO for symbol recovery in a variable rate QPSK receiver. More...
class  unquantized_mixed_type
 Determine type to use when mixing two types. More...
class  unquantized_mixed_type< complex< T >, D >
class  unquantized_mixed_type< T, complex< D > >
class  unquantized_type
 Determine unquantized version of particular type, i.e complex<long> -> complex<double>, etc. More...
class  unquantized_type< complex< T > >
class  vco
 Voltage controlled oscillator with complex output. More...
class  vector
class  viterbi
 A Viterbi decoder (for DVB). More...

Typedefs

typedef complex< float_type > CPLX
 General Purpose C++ complex FFT Transform.
typedef long natural
typedef long long long_long
typedef double float_type
typedef builtin< float > Float
typedef builtin< double > Double
typedef builtin< int > Int
typedef builtin< long > Long
typedef complex< float > complex_f
typedef complex< double > complex_d
typedef complex< int > complex_i
typedef complex< long int > complex_l
typedef complex< builtin<
float > > 		complex_F
typedef complex< builtin<
double > > 		complex_D
typedef complex< builtin<
int > > 		complex_I
typedef complex< builtin<
long int > > 		complex_L

Functions

template<class T>
smart_array< T > auto_corr (smart_array< T > x)
 Compute the autocorrelation of the Vector.
std::ostream & operator<< (std::ostream &output, const bit &inbin)
std::istream & operator>> (std::istream &input, bit &outbin)
template<class T>
T bpsk_dd_phase (complex< T > curr, complex< T > hard_data)
 Decision directed carrier phase discriminator for BPSK.
template<class T>
T bpsk_quadricorrelator (complex< T > hard_data, complex< T > prev)
 BPSK Quadricorrelator frequency discriminator.
template<class T>
builtin< T > operator+ (const builtin< T > &bi)
template<class T>
builtin< T > operator- (const builtin< T > &bi)
template<class T>
builtin< T > operator~ (const builtin< T > &bi)
template<class T>
builtin< T > operator! (const builtin< T > &bi)
template<class T>
std::istream & operator>> (std::istream &s, builtin< T > &bi)
template<class T>
std::ostream & operator<< (std::ostream &s, const builtin< T > &bi)
template<class T>
builtin< T > operator>> (const builtin< T > &bi, int i)
template<class T>
builtin< T > operator<< (const builtin< T > &bi, int i)
template<class T>
builtin< T > operator>> (const builtin< T > &bi, long i)
template<class T>
builtin< T > operator<< (const builtin< T > &bi, long i)
template<class T>
bool operator== (const builtin< T > &bi1, const builtin< T > &bi2)
template<class T>
bool operator!= (const builtin< T > &bi1, const builtin< T > &bi2)
template<class T>
bool operator< (const builtin< T > &bi1, const builtin< T > &bi2)
template<class T>
bool operator<= (const builtin< T > &bi1, const builtin< T > &bi2)
template<class T>
bool operator> (const builtin< T > &bi1, const builtin< T > &bi2)
template<class T>
bool operator>= (const builtin< T > &bi1, const builtin< T > &bi2)
template<class T>
builtin< T > operator+ (const builtin< T > &bi1, const builtin< T > &bi2)
template<class T>
builtin< T > operator- (const builtin< T > &bi1, const builtin< T > &bi2)
template<class T>
builtin< T > operator * (const builtin< T > &bi1, const builtin< T > &bi2)
template<class T>
builtin< T > operator/ (const builtin< T > &bi1, const builtin< T > &bi2)
template<>
builtin< double > operator<< (const builtin< double > &bi, int i)
template<>
builtin< double > operator>> (const builtin< double > &bi, int i)
template<>
builtin< double > operator<< (const builtin< double > &bi, long i)
template<>
builtin< double > operator>> (const builtin< double > &bi, long i)
template<>
builtin< float > operator<< (const builtin< float > &bi, int i)
template<>
builtin< float > operator>> (const builtin< float > &bi, int i)
template<>
builtin< float > operator<< (const builtin< float > &bi, long i)
template<>
builtin< float > operator>> (const builtin< float > &bi, long i)
template<class T>
smart_array< T > burg (smart_array< T > x, int P)
 AR model coefficients calculation using Burg algorithm.
void butterworth_allpass (smart_array< float_type > &a0, smart_array< float_type > &a1, int L)
 Calculate Allpass coefficients for halfband bireciprocal wave filter.
void butterworth_fir (fir_coeff< float_type > &butfir, float_type spb)
 Calculate coefficients for FIR assuming butterworth frequency response.
void butterworth_iir (iir_coeff &filt, float_type fcd, float_type amax)
 Calculate coefficients for IIR assuming butterworth frequency response.
void butterworth_s (smart_array< complex< float_type > > poles, smart_array< complex< float_type > > zeros, float_type wp, long n, long n2)
 Calculate roots.
void chebyshev_iir (iir_coeff &cheb, float_type fcd, float_type ripple)
 Calculate coefficients for IIR assuming chebyshev frequency response.
void chebyshev_s (smart_array< complex< float_type > > poles, smart_array< complex< float_type > > zeros, float_type wp, float_type epi, long n, long n2)
 Calculate poles (chebyshev).
template<typename T>
complex< T > complexj (void)
 Complex value (0,1).
template<typename T>
complex< T > conjugate (complex< T > x)
 Conjugate.
template<typename T>
T magnitude_squared (complex< T > x)
 Magnitude Squared of complex vector (also norm).
template<typename T>
T norm (complex< T > x)
 Magnitude Squared of complex vector (also magnitude_squared).
template<typename T>
complex< double > normalized (complex< T > x)
 Normalized vector (magnitude = 1).
template<typename T>
complex< T > real_mult (complex< T > r, complex< T > l)
 only get real part of result
template<typename T>
complex< T > reals_only_mult (complex< T > r, complex< T > l)
 only get product of real parts
template<typename T>
T approx_mag (complex< T > x)
 Approximate magnitude function.
template<typename T>
double arg (const complex< T > x)
 Return phase angle (radians) of complex number.
template<typename T>
complex< double > rational (complex< T > l)
 Convert to complex<double>.
template<typename T>
complex< double > reciprocal (complex< T > x)
template<class T>
std::ostream & operator<< (std::ostream &os, complex< T > r)
 -------------------- I/O operators---------------------------------------
template<class T>
std::istream & operator>> (std::istream &os, complex< T > r)
template<typename T>
complex< T > operator<< (complex< T > r, const long shift)
 Left shift (needs override for double).
template<typename T>
complex< T > operator>> (complex< T > r, const long shift)
 Right shift (needs override for double).
template<>
complex< double > operator<< (complex< double > r, const long shift)
 Left shift.
template<>
complex< double > operator>> (complex< double > r, const long shift)
 Right shift.
template<>
complex< float > operator<< (complex< float > r, const long shift)
template<>
complex< float > operator>> (complex< float > r, const long shift)
 Right shift.
template<typename T>
base_type< T >::btype magsq (T in)
 Templated Magnitude Squared function template function that uses a class to allow template specialization.
template<typename T1, typename T2>
bool operator== (complex< T1 > r, complex< T2 > l)
template<typename T1, typename T2>
bool operator<= (complex< T1 > r, complex< T2 > l)
 !
template<typename T1, typename T2>
bool operator< (complex< T1 > r, complex< T2 > l)
 !
template<typename T1, typename T2>
bool operator>= (complex< T1 > r, complex< T2 > l)
 !
template<typename T1, typename T2>
bool operator> (complex< T1 > r, complex< T2 > l)
 !
template<typename T1, typename T2>
bool operator!= (complex< T1 > r, complex< T2 > l)
template<typename T>
T conj (T in)
 Templated conjugate function template function that uses a class to allow template specialization.
template<class T>
smart_array< T > convolve (smart_array< T > x, smart_array< T > y)
template<class T>
T cp_afc (complex< T > prev, complex< T > curr)
 Cross-Product frequency discriminator.
void create_remez_fir (fir_coeff< float_type > &remezfir, int jtype, int nbands, smart_array< float_type > edge, smart_array< float_type > fx, smart_array< float_type > wtx)
void create_remez_lpfir (fir_coeff< float_type > &remezfir, float_type pass_edge, float_type stop_edge, float_type stop_weight)
 Calculate coefficients for lowpass FIR assuming equiripple frequency response.
template<class T>
T dd_symbol (complex< T > prev, complex< T > curr, complex< T > prev_hard_data, complex< T > hard_data)
 Decision directed timing discriminator (QPSK).
void elliptic_allpass (smart_array< float_type > a0, smart_array< float_type > a1, float_type fp, int L)
 Calculate Allpass coefficients for halfband bireciprocal wave filter.
void elliptic_iir (iir_coeff &filt, float_type fcd, float_type fstop, float_type stopattn, float_type ripple)
 Calculate coefficients for IIR assuming elliptic frequency response.
float_type lamda_plane (float_type k, float_type m, int n, float_type eps)
 get roots in Lamda plane
void s_plane (smart_array< complex< float_type > > roots, smart_array< complex< float_type > > zeros, int n, float_type u, float_type m, float_type k, float_type Kk, float_type wc)
 calculate s plane poles and zeros
int ellpj (float_type u, float_type m, float_type &sn, float_type &cn, float_type &dn)
float_type ellik (float_type phi, float_type k)
float_type ellpk (float_type k)
float_type msqrt (float_type u)
 modulus from ratio of K/K'
void fft (smart_array< complex< float_type > > y, int n)
 fast fourier transforms (FFT)
smart_array< complex< float_type > > find_roots (smart_array< float_type > a, long n)
 Calculate the complex roots of a polynomial equation.
template<class Numeric, class Coeff>
smart_array< Coeff > get_taps (fir< Numeric, Coeff > f)
template<class Numeric, class Coeff>
smart_array< Numeric > get_input (fir< Numeric, Coeff > f)
template<class T>
smart_array< T > get_taps (fir_coeff< T > f)
void inv_dft_symmetric (smart_array< float_type > h, smart_array< float_type > A, int N)
 Calculate coefficients for FIR using frequency sampling IDFT.
void inv_dft (smart_array< float_type > h, smart_array< float_type > A, int N)
 calculates fir filter coefficients based on frequency sampling design using IDFT
template<class T>
smart_array< T > fliplr (smart_array< T > x)
 fliplr - same as matlab function
template<class T>
complex< float_type > freqz_point (smart_array< T > b, smart_array< T > a, float_type freq, int N)
 frequency transfer function at freq with iir A and B equations
template<class T>
float_type freqz_mag_point (smart_array< T > x, float_type freq, int N)
 frequency magnitude function at freq with fir x
template<class T>
complex< float_type > freqz_point (T a, float_type freq)
 frequency transfer function at freq for 1st order allpass
template<class T>
smart_array< complex< float_type > > freqz (smart_array< T > b, smart_array< T > a, int pts)
 frequency transfer function over "pts" points for IIR
template<class T>
smart_array< complex< float_type > > freqz_mag (smart_array< T > b, smart_array< T > a, int pts)
 frequency magnitude function over "pts" points for IIR
template<class T>
smart_array< complex< float_type > > freqz_fir (smart_array< T > x, int pts)
 frequency magnitude function over "pts" points for FIR
void gaussian_fir (fir_coeff< float_type > &gaussf, float_type bt, float_type spb)
 Calculate coefficients for FIR assuming gaussian frequency response.
void idft (smart_array< complex< float_type > > y, int n)
 inverse discrete fourier transforms (IDFT)
void dft (smart_array< complex< float_type > > y, int n)
 discrete fourier transforms (DFT)
void ifft (smart_array< complex< float_type > > y, int n)
 inverse fast fourier transforms (IFFT)
template<class T>
smart_array< T > levdur (smart_array< T > R)
 Template class for Levinson-Durbin algorithm.
int dummy_cl (complex< long > z)
 Dummy functions for library instantations.
int dummy_vf (void)
template matrix< double > operator+ (const matrix< double > &m1, const matrix< double > &m2)
template matrix< double > operator+ (const matrix< double > &m, double t)
template matrix< double > operator+ (double t, const matrix< double > &m)
template matrix< double > operator- (const matrix< double > &m1, const matrix< double > &m2)
template matrix< double > operator- (const matrix< double > &m, double t)
template matrix< double > operator- (double t, const matrix< double > &m)
template matrix< double > operator- (const matrix< double > &m)
template matrix< double > operator * (const matrix< double > &m, double t)
template matrix< double > operator * (double t, const matrix< double > &m)
template<class T>
matrix< T > operator+ (const matrix< T > &m1, const matrix< T > &m2)
template<class T>
matrix< T > operator+ (const matrix< T > &m, T t)
template<class T>
matrix< T > operator+ (T t, const matrix< T > &m)
template<class T>
matrix< T > operator- (const matrix< T > &m1, const matrix< T > &m2)
template<class T>
matrix< T > operator- (const matrix< T > &m, T t)
template<class T>
matrix< T > operator- (T t, const matrix< T > &m)
template<class T>
matrix< T > operator- (const matrix< T > &m)
template<class T>
matrix< T > operator * (const matrix< T > &m1, const matrix< T > &m2)
template<class T>
vector< T > operator * (const matrix< T > &m, const vector< T > &v)
template<class T>
vector< T > operator * (const vector< T > &v, const matrix< T > &m)
template<class T>
matrix< T > operator * (const matrix< T > &m, T t)
template<class T>
matrix< T > operator * (T t, const matrix< T > &m)
bool reduce (long x, long n)
 Exclusive or the bits in x together.
float_type erfc1 (float_type x)
 Standard erfc1 function.
float_type erf1 (float_type x)
 Standard erf1 function.
void swap (int *a, int *b)
 Swap two integers.
void quicksort (int *v, unsigned n)
 Quicksort routine for array of integers.
template<class T>
T nda_symbol (complex< T > prev, complex< T > curr)
 Non-decision aided timing discriminator (Gardiner's algorithm).
float_type notch_example (float_type x)
template<class T>
smart_array< T > partial_convolve (smart_array< T > x, smart_array< T > y, int N, int M)
template<class T>
complex< float_type > ptr_freqz_point (T *b, T *a, float_type freq, int N)
 frequency transfer function at freq with iir A and B equations
template<class T>
float_type ptr_freqz_mag_point (T *x, float_type freq, int N)
 frequency magnitude function at freq with fir x
template<class T>
complex< float_type > ptr_freqz_point (T a, float_type freq)
 frequency transfer function at freq for 1st order allpass
template<class T>
void freqz (complex< float_type > *f, T *b, T *a, int N, int pts)
 frequency transfer function over "pts" points for IIR
template<class T>
void ptr_freqz_mag (float_type *f, T *b, T *a, int N, int pts)
 frequency magnitude function over "pts" points for IIR
template<class T>
void ptr_freqz_fir (complex< float_type > *f, T *x, int N, int pts)
 frequency magnitude function over "pts" points for FIR
void qam_data_demap (long rate_index, complex< long > data_in, long soft_decision_level, smart_array< long > viterbi_input)
 Soft-decision QAM Demapper (used in 802.11A).
void bpsk_soft_decision (complex< long > data_in, smart_array< long > viterbi_input)
 BPSK data demapping.
void qpsk_soft_decision (complex< long > data_in, smart_array< long > viterbi_input)
 QPSK data demapping.
void qam16_soft_decision (complex< long > data_in, long soft_decision_level, smart_array< long > viterbi_input)
 16-QAM data demapping
void qam64_soft_decision (complex< long > data_in, long soft_decision_level, smart_array< long > viterbi_input)
 64-QAM data demapping
template<class T>
T qpsk_dd_phase (complex< T > curr, complex< T > hard_data)
 Decision directed carrier phase discriminator for QPSK.
template<class T>
T qpsk_quadricorrelator (complex< T > hard_data, complex< T > prev)
template<class T>
T qpsk_rcfd (complex< T > fmf, complex< T > curr)
template<typename T>
quantized_type< T >::dtype quantize (T in)
 Templated Quantize function template function that uses a class to allow template specialization.
template<typename T>
T quantize_scale (float_type x, float_type ox, T y)
template<class T>
void raised_cosine (fir_coeff< T > &rcfir, float_type alpha, int rate)
 Raised Cosine functions.
float_type raised_cosine_imp (float_type alpha, float_type xin, float_type rate, long num_taps)
template<class T>
long real_quantize (T in)
 Templated quantize function.
template<class T>
T real_round (T in, long bits)
 Templated round function.
template<>
long real_round (long in, long bits)
template<>
float real_round (float in, long bits)
template<>
int real_round (int in, long bits)
template<>
double real_round (double in, long bits)
template<class T>
T real_saturate (T in, long bits)
 Templated saturation functions.
template<>
long real_saturate (long in, long bits)
 Templated saturation functions.
template<>
int real_saturate (int in, long bits)
template<>
double real_saturate (double in, long bits)
template<>
float real_saturate (float in, long bits)
template<float_type Des_function, float_type Weight_function>
float_type * remez_function (int numtaps, int numband, int r, float_type bands[], int type)
template<class T>
void root_raised_cosine_quantized (fir_coeff< T > &rcfir, float_type alpha, int rate, int bits, float_type scale)
 Root Raised Cosine functions.
template<class T>
void root_raised_cosine (fir_coeff< T > &rcfir, float_type alpha, int rate)
float_type root_raised_cosine_imp (float_type alpha, float_type xin, float_type rate, long num_taps)
template<>
void root_raised_cosine_quantized (fir_coeff< long > &rcfir, float_type alpha, int rate, int bits, float_type scale)
template<>
void root_raised_cosine_quantized (fir_coeff< float > &rcfir, float_type alpha, int rate, int bits, float_type scale)
template<>
void root_raised_cosine_quantized (fir_coeff< int > &rcfir, float_type alpha, int rate, int bits, float_type scale)
template<>
void root_raised_cosine_quantized (fir_coeff< double > &rcfir, float_type alpha, int rate, int bits, float_type scale)
template<class T>
T round (T in, long bits)
 Templated round function template function that uses a class to allow template specialization.
template<class T>
T saturate (T in, long bits)
 Templated saturate function template function that uses a class to allow template specialization.
template<typename T>
T signbit (T in)
 Templated signbit function template function that uses a class to allow template specialization.
template<typename T>
T MAX (T a, T b)
template<typename T>
T MIN (T a, T b)
template<typename T>
T ABS (T a)
template<typename T>
T SQR (T a)
template<typename T>
T SGN (T a)
float_type sqrt (float_type x)
 sqrt
float_type cos (float_type x)
complex< float_type > sqrt (complex< float_type > x)
 sqrt
complex< float_type > sqrt (complex< long > x)
 sqrt
float_type coshin (float_type x)
float_type arccos (float_type x)
float_type cosh (float_type x)
float_type sinh (float_type x)
complex< float_type > cos (complex< float_type > x)
complex< float_type > polar (float_type amp, float_type arg)
 Polar to rectangular conversion.
complex< float_type > exp (complex< float_type > x)
 complex exponential
float_type hypot (complex< float_type > z)
complex< float > expj (float x)
complex< double > expj (double x)
template<class T>
void toeplitz (vector< T > x, matrix< T > &A)
 Get Symmetric Toeplitz matrix from vector.
template<class T>
std::ostream & operator<< (std::ostream &os, const vector< T > &v)
template<class T>
vector< T > operator+ (const vector< T > &v1, const vector< T > &v2)
template<class T>
vector< T > operator- (const vector< T > &v1, const vector< T > &v2)
template<class T>
vector< T > operator- (const vector< T > &v)
template<class T>
vector< T > operator * (const vector< T > &v, const T t)
template<class T>
vector< T > operator * (const T t, const vector< T > &v)
template<class T>
vector< T > elem_mult (const vector< T > &v1, const vector< T > &v2)
template<class T>
vector< T > operator * (const vector< T > &v1, const vector< T > &v2)
template<class T>
vector< T > operator/ (const vector< T > &v, const T t)
template<class T>
vector< T > operator/ (const T t, const vector< T > &v)
template<class T>
vector< T > elem_div (const vector< T > &v1, const vector< T > &v2)
template<class T>
vector< T > elem_div (const T t, const vector< T > &v)
template<class T>
vector< T > to_vector (smart_array< T > y)
template<class T>
void copy_vector (smart_array< T > x, smart_array< T > y)
float_type io (float_type x)
 bessel function for kaiser window
smart_array< float_type > hamming (long nf, float_type alpha, float_type beta)
 hamming window $ w(n) = alpha + beta*cos( 2*\pi*(n-1)/(nf-1) )$
smart_array< float_type > hanning (long nf)
 hanning window $ w(n) = 0.5( 1 - cos( 2*\pi*n/(nf-1) )$
smart_array< float_type > blackman (long nf)
 Blackman Window $ w[x] = 0.42 - 0.5*cos(2*\pi*x/nf) + 0.08*cos(2*\pi*x/nf)$.
smart_array< float_type > kaiser (long nf, float_type beta)
 kaiser window
smart_array< float_type > cheby (long nf, long n, long ieo, float_type dp, float_type df, float_type x0)
 dolph chebyshev window design
void chebc (float_type nf, float_type dp, float_type df, float_type n, float_type x0)
 chebyshev window

Variables

long cmult_count = 0
long hcmult_count = 0
long rmult_count = 0
long div_count = 0
long hdiv_count = 0
long cadd_count = 0
long hcadd_count = 0

Detailed Description

Author:
Tony Kirke

Typedef Documentation

typedef long SPUC::natural

typedef long long SPUC::long_long

typedef double SPUC::float_type

typedef builtin<float> SPUC::Float

typedef builtin<double> SPUC::Double

typedef builtin<int> SPUC::Int

typedef builtin<long> SPUC::Long

typedef complex<float> SPUC::complex_f

typedef complex<double> SPUC::complex_d

typedef complex<int> SPUC::complex_i

typedef complex<long int> SPUC::complex_l

typedef complex<builtin<float> > SPUC::complex_F

typedef complex<builtin<double> > SPUC::complex_D

typedef complex<builtin<int> > SPUC::complex_I

typedef complex<builtin<long int> > SPUC::complex_L

Function Documentation

std::ostream & SPUC::operator<< ( std::ostream &  output,
const bit &  inbin 
)

std::istream & SPUC::operator>> ( std::istream &  input,
bit &  outbin 
)

template<class T>
builtin<T> SPUC::operator+ ( const builtin< T > &  bi  )  [inline]

template<class T>
builtin<T> SPUC::operator- ( const builtin< T > &  bi  )  [inline]

template<class T>
builtin<T> SPUC::operator~ ( const builtin< T > &  bi  )  [inline]

template<class T>
builtin<T> SPUC::operator! ( const builtin< T > &  bi  )  [inline]

template<class T>
std::istream& SPUC::operator>> ( std::istream &  s,
builtin< T > &  bi 
) [inline]

template<class T>
std::ostream& SPUC::operator<< ( std::ostream &  s,
const builtin< T > &  bi 
) [inline]

template<class T>
builtin<T> SPUC::operator>> ( const builtin< T > &  bi,
int  i 
) [inline]

template<class T>
builtin<T> SPUC::operator<< ( const builtin< T > &  bi,
int  i 
) [inline]

template<class T>
builtin<T> SPUC::operator>> ( const builtin< T > &  bi,
long  i 
) [inline]

template<class T>
builtin<T> SPUC::operator<< ( const builtin< T > &  bi,
long  i 
) [inline]

template<class T>
bool SPUC::operator== ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
) [inline]

template<class T>
bool SPUC::operator!= ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
) [inline]

template<class T>
bool SPUC::operator< ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
) [inline]

template<class T>
bool SPUC::operator<= ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
) [inline]

template<class T>
bool SPUC::operator> ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
) [inline]

template<class T>
bool SPUC::operator>= ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
) [inline]

template<class T>
builtin<T> SPUC::operator+ ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
) [inline]

template<class T>
builtin<T> SPUC::operator- ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
) [inline]

template<class T>
builtin<T> SPUC::operator * ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
) [inline]

template<class T>
builtin<T> SPUC::operator/ ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
) [inline]

template<>
builtin<double> SPUC::operator<< ( const builtin< double > &  bi,
int  i 
) [inline]

template<>
builtin<double> SPUC::operator>> ( const builtin< double > &  bi,
int  i 
) [inline]

template<>
builtin<double> SPUC::operator<< ( const builtin< double > &  bi,
long  i 
) [inline]

template<>
builtin<double> SPUC::operator>> ( const builtin< double > &  bi,
long  i 
) [inline]

template<>
builtin<float> SPUC::operator<< ( const builtin< float > &  bi,
int  i 
) [inline]

template<>
builtin<float> SPUC::operator>> ( const builtin< float > &  bi,
int  i 
) [inline]

template<>
builtin<float> SPUC::operator<< ( const builtin< float > &  bi,
long  i 
) [inline]

template<>
builtin<float> SPUC::operator>> ( const builtin< float > &  bi,
long  i 
) [inline]

void SPUC::butterworth_s ( smart_array< complex< float_type > >  poles,
smart_array< complex< float_type > >  zeros,
float_type  wp,
long  n,
long  n2 
)

Calculate roots.

void SPUC::chebyshev_s ( smart_array< complex< float_type > >  poles,
smart_array< complex< float_type > >  zeros,
float_type  wp,
float_type  epi,
long  n,
long  n2 
)

Calculate poles (chebyshev).

template<typename T>
complex<T> SPUC::complexj ( void   )  [inline]

Complex value (0,1).

template<typename T>
complex<T> SPUC::conjugate ( complex< T >  x  )  [inline]

Conjugate.

template<typename T>
T SPUC::magnitude_squared ( complex< T >  x  )  [inline]

Magnitude Squared of complex vector (also norm).

template<typename T>
T SPUC::norm ( complex< T >  x  )  [inline]

Magnitude Squared of complex vector (also magnitude_squared).

template<typename T>
complex<double> SPUC::normalized ( complex< T >  x  )  [inline]

Normalized vector (magnitude = 1).

template<typename T>
complex<T> SPUC::real_mult ( complex< T >  r,
complex< T >  l 
) [inline]

only get real part of result

template<typename T>
complex<T> SPUC::reals_only_mult ( complex< T >  r,
complex< T >  l 
) [inline]

only get product of real parts

template<typename T>
T SPUC::approx_mag ( complex< T >  x  )  [inline]

Approximate magnitude function.

template<typename T>
double SPUC::arg ( const complex< T >  x  )  [inline]

Return phase angle (radians) of complex number.

template<typename T>
complex<double> SPUC::rational ( complex< T >  l  )  [inline]

Convert to complex<double>.

template<typename T>
complex<double> SPUC::reciprocal ( complex< T >  x  )  [inline]

template<class T>
std::ostream& SPUC::operator<< ( std::ostream &  os,
complex< T >  r 
)

-------------------- I/O operators---------------------------------------

template<class T>
std::istream& SPUC::operator>> ( std::istream &  os,
complex< T >  r 
)

template<typename T>
complex<T> SPUC::operator<< ( complex< T >  r,
const long  shift 
) [inline]

Left shift (needs override for double).

template<typename T>
complex<T> SPUC::operator>> ( complex< T >  r,
const long  shift 
) [inline]

Right shift (needs override for double).

template<>
complex<double> SPUC::operator<< ( complex< double >  r,
const long  shift 
) [inline]

Left shift.

template<>
complex<double> SPUC::operator>> ( complex< double >  r,
const long  shift 
) [inline]

Right shift.

template<>
complex<float> SPUC::operator<< ( complex< float >  r,
const long  shift 
) [inline]

template<>
complex<float> SPUC::operator>> ( complex< float >  r,
const long  shift 
) [inline]

Right shift.

template<typename T1, typename T2>
bool SPUC::operator== ( complex< T1 >  r,
complex< T2 >  l 
) [inline]

template<typename T1, typename T2>
bool SPUC::operator<= ( complex< T1 >  r,
complex< T2 >  l 
) [inline]

!

template<typename T1, typename T2>
bool SPUC::operator< ( complex< T1 >  r,
complex< T2 >  l 
) [inline]

!

template<typename T1, typename T2>
bool SPUC::operator>= ( complex< T1 >  r,
complex< T2 >  l 
) [inline]

!

template<typename T1, typename T2>
bool SPUC::operator> ( complex< T1 >  r,
complex< T2 >  l 
) [inline]

!

template<typename T1, typename T2>
bool SPUC::operator!= ( complex< T1 >  r,
complex< T2 >  l 
) [inline]

void SPUC::create_remez_fir ( fir_coeff< float_type > &  remezfir,
int  jtype,
int  nbands,
smart_array< float_type >  edge,
smart_array< float_type >  fx,
smart_array< float_type >  wtx 
)

float_type SPUC::lamda_plane ( float_type  k,
float_type  m,
int  n,
float_type  eps 
)

get roots in Lamda plane

void SPUC::s_plane ( smart_array< complex< float_type > >  roots,
smart_array< complex< float_type > >  zeros,
int  n,
float_type  u,
float_type  m,
float_type  k,
float_type  Kk,
float_type  wc 
)

calculate s plane poles and zeros

int SPUC::ellpj ( float_type  u,
float_type  m,
float_type &  sn,
float_type &  cn,
float_type &  dn 
)

float_type SPUC::ellik ( float_type  phi,
float_type  k 
)

float_type SPUC::ellpk ( float_type  k  ) 

float_type SPUC::msqrt ( float_type  u  ) 

modulus from ratio of K/K'

template<class Numeric, class Coeff>
smart_array<Coeff> SPUC::get_taps ( fir< Numeric, Coeff >  f  ) 

template<class Numeric, class Coeff>
smart_array<Numeric> SPUC::get_input ( fir< Numeric, Coeff >  f  ) 

template<class T>
smart_array<T> SPUC::get_taps ( fir_coeff< T >  f  ) 

void SPUC::inv_dft ( smart_array< float_type >  h,
smart_array< float_type >  A,
int  N 
)

calculates fir filter coefficients based on frequency sampling design using IDFT

int SPUC::dummy_cl ( complex< long >  z  ) 

Dummy functions for library instantations.

int SPUC::dummy_vf ( void   ) 

template matrix<double> SPUC::operator+ ( const matrix< double > &  m1,
const matrix< double > &  m2 
)

template matrix<double> SPUC::operator+ ( const matrix< double > &  m,
double  t 
)

template matrix<double> SPUC::operator+ ( double  t,
const matrix< double > &  m 
)

template matrix<double> SPUC::operator- ( const matrix< double > &  m1,
const matrix< double > &  m2 
)

template matrix<double> SPUC::operator- ( const matrix< double > &  m,
double  t 
)

template matrix<double> SPUC::operator- ( double  t,
const matrix< double > &  m 
)

template matrix<double> SPUC::operator- ( const matrix< double > &  m  ) 

template matrix<double> SPUC::operator * ( const matrix< double > &  m,
double  t 
)

template matrix<double> SPUC::operator * ( double  t,
const matrix< double > &  m 
)

template<class T>
matrix<T> SPUC::operator+ ( const matrix< T > &  m1,
const matrix< T > &  m2 
) [inline]

template<class T>
matrix<T> SPUC::operator+ ( const matrix< T > &  m,
T  t 
) [inline]

template<class T>
matrix<T> SPUC::operator+ ( T  t,
const matrix< T > &  m 
) [inline]

template<class T>
matrix<T> SPUC::operator- ( const matrix< T > &  m1,
const matrix< T > &  m2 
) [inline]

template<class T>
matrix<T> SPUC::operator- ( const matrix< T > &  m,
T  t 
) [inline]

template<class T>
matrix<T> SPUC::operator- ( T  t,
const matrix< T > &  m 
) [inline]

template<class T>
matrix<T> SPUC::operator- ( const matrix< T > &  m  )  [inline]

template<class T>
matrix<T> SPUC::operator * ( const matrix< T > &  m1,
const matrix< T > &  m2 
) [inline]

template<class T>
vector<T> SPUC::operator * ( const matrix< T > &  m,
const vector< T > &  v 
) [inline]

template<class T>
vector<T> SPUC::operator * ( const vector< T > &  v,
const matrix< T > &  m 
) [inline]

template<class T>
matrix<T> SPUC::operator * ( const matrix< T > &  m,
T  t 
) [inline]

template<class T>
matrix<T> SPUC::operator * ( T  t,
const matrix< T > &  m 
) [inline]

float_type SPUC::notch_example ( float_type  x  ) 

template<typename T>
T SPUC::quantize_scale ( float_type  x,
float_type  ox,
T  y 
)

float_type SPUC::raised_cosine_imp ( float_type  alpha,
float_type  xin,
float_type  rate,
long  num_taps 
)

template<>
long SPUC::real_round ( long  in,
long  bits 
) [inline]

template<>
float SPUC::real_round ( float  in,
long  bits 
) [inline]

template<>
int SPUC::real_round ( int  in,
long  bits 
) [inline]

template<>
double SPUC::real_round ( double  in,
long  bits 
) [inline]

template<>
int SPUC::real_saturate ( int  in,
long  bits 
) [inline]

template<>
double SPUC::real_saturate ( double  in,
long  bits 
) [inline]

template<>
float SPUC::real_saturate ( float  in,
long  bits 
) [inline]

template<float_type Des_function, float_type Weight_function>
float_type* SPUC::remez_function ( int  numtaps,
int  numband,
int  r,
float_type  bands[],
int  type 
)

Author:
Tony Kirke, Copyright(c) 2001

float_type SPUC::root_raised_cosine_imp ( float_type  alpha,
float_type  xin,
float_type  rate,
long  num_taps 
)

template<typename T>
T SPUC::MAX ( T  a,
T  b 
)

template<typename T>
T SPUC::MIN ( T  a,
T  b 
)

template<typename T>
T SPUC::ABS ( T  a  ) 

template<typename T>
T SPUC::SQR ( T  a  ) 

template<typename T>
T SPUC::SGN ( T  a  ) 

complex<double> SPUC::expj ( double  x  )  [inline]

template<class T>
std::ostream & SPUC::operator<< ( std::ostream &  os,
const vector< T > &  v 
)

template<class T>
vector<T> SPUC::operator+ ( const vector< T > &  v1,
const vector< T > &  v2 
) [inline]

template<class T>
vector<T> SPUC::operator- ( const vector< T > &  v1,
const vector< T > &  v2 
) [inline]

template<class T>
vector<T> SPUC::operator- ( const vector< T > &  v  )  [inline]

template<class T>
vector<T> SPUC::operator * ( const vector< T > &  v,
const T  t 
) [inline]

template<class T>
vector<T> SPUC::operator * ( const T  t,
const vector< T > &  v 
) [inline]

template<class T>
vector<T> SPUC::elem_mult ( const vector< T > &  v1,
const vector< T > &  v2 
) [inline]

template<class T>
vector<T> SPUC::operator * ( const vector< T > &  v1,
const vector< T > &  v2 
) [inline]

template<class T>
vector<T> SPUC::operator/ ( const vector< T > &  v,
const T  t 
) [inline]

template<class T>
vector<T> SPUC::operator/ ( const T  t,
const vector< T > &  v 
) [inline]

template<class T>
vector<T> SPUC::elem_div ( const vector< T > &  v1,
const vector< T > &  v2 
) [inline]

template<class T>
vector<T> SPUC::elem_div ( const T  t,
const vector< T > &  v 
) [inline]

template<class T>
vector<T> SPUC::to_vector ( smart_array< T >  y  )  [inline]

template<class T>
void SPUC::copy_vector ( smart_array< T >  x,
smart_array< T >  y 
) [inline]

Variable Documentation

long SPUC::cmult_count = 0

long SPUC::hcmult_count = 0

long SPUC::rmult_count = 0

long SPUC::div_count = 0

long SPUC::hdiv_count = 0

long SPUC::cadd_count = 0

long SPUC::hcadd_count = 0

Generated on Mon Jun 9 19:40:30 2008 for DSPTemplates by  doxygen 1.4.7