SPUC  3.0
Classes | Typedefs | Enumerations | Functions | Variables
SPUC Namespace Reference

fixed point types: spuc_fixed,spuc_ufixed,spuc_int,spuc_uint More...

Classes

class  a_d
 An A/D conversion class. More...
 
struct  Abs_Func
 Template functions to use in Compile-time Template Parameters : Absolute Value. 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  array1d
 
class  array2d
 
class  base_demod
 base class for a demodulator (not currently used?) More...
 
singleton  base_type
 Determine base class for complex, builtin, sint, etc, classes. More...
 
class  base_type< builtin< T > >
 
class  base_type< complex< 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...
 
singleton  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  cascaded_cic
 
class  cfft
 
class  cic
 class for CIC digital filter More...
 
class  circ_buffer
 Circular Buffer. More...
 
singleton  complex
 Spuc template complex class. More...
 
singleton  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  equalizer
 
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  fast_equalizer
 
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  fixed_delay
 Template class for Delay line with Fixed Delay. 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  hash_map
 Class that implements a hash map with string key. More...
 
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_allpass_variable_cascade
 
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
 
struct  int_size_needed
 
struct  int_type_size
 Use Template parameter to select int type, default is error, should go to one of the specializations below. More...
 
struct  int_type_size< 128 >
 
struct  int_type_size< 16 >
 Specialization for 16 bits. More...
 
struct  int_type_size< 32 >
 Specialization for 32 bits. More...
 
struct  int_type_size< 64 >
 Specialization for 64 bits. More...
 
struct  int_type_size< 8 >
 Specialization for 8 bits. More...
 
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...
 
singleton  magsqr
 
class  magsqr< complex< T > >
 
singleton  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  nested_allpass_1
 
class  nested_iir_allpass_2
 
class  nested_iir_allpass_tmp
 
class  nested_shelf_allpass_2
 
struct  NEXT_INT_SIZE
 For mapping to minimum integer type size. More...
 
class  noise
 Gaussian noise routine. More...
 
class  notch_allpass
 IIR notch filter based on 2nd order allpass structure. More...
 
class  notch_comb
 
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 > >
 
singleton  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_average
 template class running average filter consisting of a delay line, adder and subtractor More...
 
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  shelf_allpass1
 IIR zolzer filter based on 2nd order allpass structure. More...
 
class  sigma_delta
 Simple 1st order All-digital Sigma Delta converter. More...
 
singleton  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...
 
struct  SMask
 
class  spuc_fixed
 A fast & lightweight fixed-point class. More...
 
class  spuc_int
 A faster version of the older systemc spuc_int. More...
 
class  spuc_round_class_function
 
class  spuc_round_class_function< SPUC_RND >
 
class  spuc_round_class_function< SPUC_TRN >
 Specialization for SPUC_TRN. More...
 
class  spuc_saturate_class_function
 
class  spuc_saturate_class_function< TOTAL_BITS_, SPUC_SAT >
 Specialized for SPUC_SAT. More...
 
class  spuc_saturate_class_function< TOTAL_BITS_, SPUC_SAT_SYM >
 Specialized for SPUC_SAT_SYM. More...
 
class  spuc_shift_class_function
 
class  spuc_shift_class_function< FRAC_BITS_, SPUC_RND >
 Specialize for SPUC_RND shift return type one extra bit to avoid overflow,. More...
 
class  spuc_shift_class_function< FRAC_BITS_, SPUC_TRN >
 Specialize for SPUC_TRN shift return type one extra bit to avoid overflow,. More...
 
class  spuc_ufixed
 A fast & lightweight fixed-point class. More...
 
class  spuc_uint
 A faster version of the older systemc spuc_uint. More...
 
class  sum_and_dump
 sum and dump filter More...
 
struct  Template_Max
 Max compile time calculation. More...
 
struct  Template_Max_Total_Bits
 Max Total Bits for spuc_fixed based on Max of two different spuc_fixed. More...
 
class  timing_nco
 A NCO for symbol recovery in a variable rate QPSK receiver. More...
 
class  uint
 Template class for unsigned integers (<33 bits). More...
 
struct  UMask
 
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...
 
class  vlog
 Logarithmic number system class. More...
 

Typedefs

typedef complex< float_typeCPLX
 General Purpose C++ complex FFT Transform. More...
 
typedef int64_t max_int_type
 Possible ranges for bit-widths. More...
 
typedef uint64_t max_uint_type
 
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
 
typedef vfloat self
 

Enumerations

enum  spuc_o_mode { SPUC_SAT, SPUC_SAT_SYM, SPUC_WRAP }
 Similar to Systemc enums. More...
 
enum  spuc_q_mode { SPUC_RND, SPUC_TRN }
 

Functions

template<class T >
std::vector< T > auto_corr (const std::vector< T > &x)
 Compute the autocorrelation of the Vector. More...
 
std::ostream & operator<< (std::ostream &output, const bit &inbin)
 
std::istream & operator>> (std::istream &input, bit &outbin)
 
template<class T >
bpsk_dd_phase (complex< T > curr, complex< T > hard_data)
 Decision directed carrier phase discriminator for BPSK. More...
 
template<class T >
bpsk_quadricorrelator (complex< T > hard_data, complex< T > prev)
 BPSK Quadricorrelator frequency discriminator. More...
 
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 >
std::vector< T > burg (std::vector< T > x, int P)
 AR model coefficients calculation using Burg algorithm. More...
 
void butterworth_allpass (std::vector< float_type > &a0, std::vector< float_type > &a1, int L)
 Calculate Allpass coefficients for halfband bireciprocal wave filter. More...
 
void butterworth_fir (fir_coeff< float_type > &butfir, float_type spb)
 Calculate coefficients for FIR assuming butterworth frequency response. More...
 
void butterworth_iir (iir_coeff &filt, float_type fcd, bool lpf, float_type amax)
 Calculate coefficients for IIR assuming butterworth frequency response. More...
 
void butterworth_s (std::vector< complex< float_type > > &poles, std::vector< complex< float_type > > &zeros, bool lpf, float_type wp, long n, long n2)
 Calculate roots. More...
 
void chebyshev_iir (iir_coeff &cheb, float_type fcd, bool lpf, float_type ripple)
 Calculate coefficients for IIR assuming chebyshev frequency response. More...
 
void chebyshev_s (std::vector< complex< float_type > > &poles, std::vector< complex< float_type > > &zeros, bool lpf, float_type wp, float_type epi, long n, long n2)
 Calculate poles (chebyshev) More...
 
template<typename T >
complex< T > complexj (void)
 Complex value (0,1) More...
 
template<typename T >
complex< T > conjugate (complex< T > x)
 Conjugate. More...
 
template<typename T >
magnitude_squared (complex< T > x)
 Magnitude Squared of complex vector (also norm) More...
 
template<typename T >
norm (complex< T > x)
 Magnitude Squared of complex vector (also magnitude_squared) More...
 
template<typename T >
complex< double > normalized (complex< T > x)
 Normalized vector (magnitude = 1) More...
 
template<typename T >
complex< T > real_mult (complex< T > r, complex< T > l)
 only get real part of result More...
 
template<typename T >
complex< T > reals_only_mult (complex< T > r, complex< T > l)
 only get product of real parts More...
 
template<typename T >
approx_mag (complex< T > x)
 Approximate magnitude function. More...
 
template<typename T >
double arg (const complex< T > x)
 Type Specific functions. More...
 
template<typename T >
double calc_angle (const complex< T > x)
 
template<typename T >
complex< double > rational (complex< T > l)
 Convert to complex<double> More...
 
template<typename T >
complex< double > reciprocal (complex< T > x)
 
template<class T >
std::ostream & operator<< (std::ostream &os, complex< T > r)
 -----------------— I/O operators------------------------------------— More...
 
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) More...
 
template<typename T >
complex< T > operator>> (complex< T > r, const long shift)
 Right shift (needs override for double) More...
 
template<>
complex< double > operator<< (complex< double > r, const long shift)
 Left shift. More...
 
template<>
complex< double > operator>> (complex< double > r, const long shift)
 Right shift. More...
 
template<>
complex< float > operator<< (complex< float > r, const long shift)
 
template<>
complex< float > operator>> (complex< float > r, const long shift)
 Right shift. More...
 
template<typename T >
base_type< T >::btype magsq (T in)
 Templated Magnitude Squared function template function that uses a class to allow template specialization. More...
 
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)
 ! More...
 
template<typename T1 , typename T2 >
bool operator< (complex< T1 > r, complex< T2 > l)
 ! More...
 
template<typename T1 , typename T2 >
bool operator>= (complex< T1 > r, complex< T2 > l)
 ! More...
 
template<typename T1 , typename T2 >
bool operator> (complex< T1 > r, complex< T2 > l)
 ! More...
 
template<typename T1 , typename T2 >
bool operator!= (complex< T1 > r, complex< T2 > l)
 
template<typename T >
conj (T in)
 Templated conjugate function template function that uses a class to allow template specialization. More...
 
template<class T >
std::vector< T > convolve (const std::vector< T > &x, const std::vector< T > &y)
 
template<class T >
cp_afc (complex< T > prev, complex< T > curr)
 Cross-Product frequency discriminator. More...
 
void create_remez_fir (fir_coeff< float_type > &remezfir, int jtype, int nbands, std::vector< float_type > edge, std::vector< float_type > fx, std::vector< float_type > wtx)
 
void create_remez_lpfir (fir_coeff< float_type > &remezfir, float_type pass_edge, float_type stop_edge, float_type stop_weight)
 calculates the coefficients for lowpass FIR based on Remez constraints More...
 
template<class T >
dd_symbol (complex< T > prev, complex< T > curr, complex< T > prev_hard_data, complex< T > hard_data)
 Decision directed timing discriminator (QPSK) More...
 
void elliptic_allpass (std::vector< float_type > &a0, std::vector< float_type > &a1, float_type fp, int L)
 Calculate Allpass coefficients for halfband bireciprocal wave filter. More...
 
void elliptic_iir (iir_coeff &filt, float_type fcd, bool lpf, float_type fstop, float_type stopattn, float_type ripple)
 Calculate coefficients for IIR assuming elliptic frequency response. More...
 
float_type lamda_plane (float_type k, float_type m, int n, float_type eps)
 get roots in Lamda plane More...
 
void s_plane (std::vector< complex< float_type > > &roots, std::vector< complex< float_type > > &zeros, bool lpf, int n, float_type u, float_type m, float_type k, float_type Kk, float_type wc)
 calculate s plane poles and zeros More...
 
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' More...
 
void fft (std::vector< complex< float_type > > y, int n)
 fast fourier transforms (FFT) More...
 
std::vector< complex
< float_type > > 
find_roots (const std::vector< float_type > &a, long n)
 Calculate the complex roots of a polynomial equation. More...
 
template<class Numeric , class Coeff >
std::vector< Coeff > get_taps (const fir< Numeric, Coeff > &f)
 
template<class Numeric , class Coeff >
std::vector< Numeric > get_input (const fir< Numeric, Coeff > &f)
 
template<class T >
std::vector< T > get_taps (fir_coeff< T > f)
 
std::vector< float_typeinv_dft_symmetric (const std::vector< float_type > &A, int N)
 Calculate coefficients for FIR using frequency sampling IDFT. More...
 
std::vector< float_typeinv_dft (const std::vector< float_type > &A, int N)
 calculates fir filter coefficients based on frequency sampling design using IDFT More...
 
template<class T >
std::vector< T > fliplr (const std::vector< T > &x)
 fliplr - same as matlab function More...
 
template<class T >
complex< float_typefreqz_point (std::vector< T > b, std::vector< T > a, float_type freq, int N)
 frequency transfer function at freq with iir A and B equations More...
 
template<class T >
float_type freqz_mag_point (std::vector< T > x, float_type freq, int N)
 frequency magnitude function at freq with fir x More...
 
template<class T >
complex< float_typefreqz_point (T a, float_type freq)
 frequency transfer function at freq for 1st order allpass More...
 
template<class T >
std::vector< complex
< float_type > > 
freqz (std::vector< T > b, std::vector< T > a, int pts)
 frequency transfer function over "pts" points for IIR More...
 
template<class T >
std::vector< complex
< float_type > > 
freqz_mag (std::vector< T > b, std::vector< T > a, int pts)
 frequency magnitude function over "pts" points for IIR More...
 
template<class T >
std::vector< complex
< float_type > > 
freqz_fir (std::vector< T > x, int pts)
 frequency magnitude function over "pts" points for FIR More...
 
void gaussian_fir (fir_coeff< float_type > &gaussf, float_type bt, float_type spb)
 Calculate coefficients for FIR assuming gaussian frequency response. More...
 
void idft (std::vector< complex< float_type > > y, int n)
 inverse discrete fourier transforms (IDFT) More...
 
void dft (std::vector< complex< float_type > > y, int n)
 discrete fourier transforms (DFT) More...
 
void ifft (std::vector< complex< float_type > > y, int n)
 inverse fast fourier transforms (IFFT) More...
 
template<class T >
std::vector< T > levdur (std::vector< T > R)
 Template class for Levinson-Durbin algorithm. More...
 
int dummy_cl (complex< long > z)
 Dummy functions for library instantations. More...
 
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. More...
 
float_type erfc1 (float_type x)
 Standard erfc1 function. More...
 
float_type erf1 (float_type x)
 Standard erf1 function. More...
 
void swap (int *a, int *b)
 Swap two integers. More...
 
void quicksort (int *v, unsigned n)
 Quicksort routine for array of integers. More...
 
template<class T >
nda_symbol (complex< T > prev, complex< T > curr)
 Non-decision aided timing discriminator (Gardiner's algorithm) More...
 
float_type notch_example (float_type x)
 
void cic_freq (int rate, int order, int pts, double *w, int freq_off, double inc)
 
template<typename T >
void other_freq (T &AP, int pts, double *w, int freq_off, double inc)
 
template<typename T >
void fir_freq (T &MF, int pts, double *w, int freq_off, double inc)
 
template<typename T >
void iir_freq (T &MF, bool hpf, int pts, int bits, double *w, int freq_off, double inc)
 
template<typename T >
void other_freq (T &AP, int pts, double *w)
 
template<typename T >
void filt_freq (T &MF, int pts, int bits, double *w)
 
template<class T >
std::vector< T > partial_convolve (const std::vector< T > &x, const std::vector< T > &y, int N, int M)
 
template<class T >
complex< float_typeptr_freqz_point (T *b, T *a, float_type freq, int N)
 frequency transfer function at freq with iir A and B equations More...
 
template<class T >
float_type ptr_freqz_mag_point (T *x, float_type freq, int N)
 frequency magnitude function at freq with fir x More...
 
template<class T >
complex< float_typeptr_freqz_point (T a, float_type freq)
 frequency transfer function at freq for 1st order allpass More...
 
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 More...
 
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 More...
 
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 More...
 
void qam_data_demap (long rate_index, complex< long > data_in, long soft_decision_level, std::vector< long > &viterbi_input)
 Soft-decision QAM Demapper for use with QAM_MOD class. More...
 
void bpsk_soft_decision (complex< long > data_in, std::vector< long > &viterbi_input)
 BPSK data demapping. More...
 
void qpsk_soft_decision (complex< long > data_in, std::vector< long > &viterbi_input)
 QPSK data demapping. More...
 
void qam16_soft_decision (complex< long > data_in, long soft_decision_level, std::vector< long > &viterbi_input)
 16-QAM data demapping More...
 
void qam64_soft_decision (complex< long > data_in, long soft_decision_level, std::vector< long > &viterbi_input)
 64-QAM data demapping More...
 
template<class T >
qpsk_dd_phase (complex< T > curr, complex< T > hard_data)
 Decision directed carrier phase discriminator for QPSK. More...
 
template<class T >
qpsk_quadricorrelator (complex< T > hard_data, complex< T > prev)
 
template<class 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. More...
 
template<typename T >
quantize_scale (float_type x, float_type ox, T y)
 
template<class T >
void raised_cosine (fir_coeff< T > &rcfir, float_type alpha, float_type rate)
 Raised Cosine functions. More...
 
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. More...
 
template<class T >
real_round (T in, long bits)
 Templated round function. More...
 
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 >
real_saturate (T in, long bits)
 Templated saturation functions. More...
 
template<>
long real_saturate (long in, long bits)
 Templated saturation functions. More...
 
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>
void remez_function (std::vector< float_type > &r_fir, int numtaps, int numband, int r, std::vector< 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. More...
 
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 >
round (T in, long bits)
 Templated round function template function that uses a class to allow template specialization. More...
 
template<class T >
saturate (T in, long bits)
 Templated saturate function template function that uses a class to allow template specialization. More...
 
double z_freqz_db (bool hpf, double f, double a, double h, double l)
 
double find_a (bool hpf, double f, double des_gain, double h, double l)
 
template<typename T >
signbit (T in)
 Templated signbit function template function that uses a class to allow template specialization. More...
 
template<typename T >
MAX (T a, T b)
 
template<typename T >
MIN (T a, T b)
 
template<typename T >
ABS (T a)
 
template<typename T >
SQR (T a)
 
template<typename T >
SGN (T a)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed
< Template_Max_Total_Bits
< TOTAL_BITS_, INT_BITS_,
TOTAL_BITS_1, INT_BITS_1 >
::maxval+1, Template_Max
< INT_BITS_, INT_BITS_1 >
::maxval+1, QMODE, OMODE > 
operator+ (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed
< Template_Max_Total_Bits
< TOTAL_BITS_, INT_BITS_,
TOTAL_BITS_1, INT_BITS_1 >
::maxval+1, Template_Max
< INT_BITS_, INT_BITS_1 >
::maxval+1, QMODE, OMODE > 
operator- (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<(TOTAL_BITS_+TOTAL_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator* (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<(TOTAL_BITS_+TOTAL_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator/ (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed
< Template_Max_Total_Bits
< TOTAL_BITS_, INT_BITS_,
TOTAL_BITS_1, INT_BITS_1 >
::maxval, Template_Max
< INT_BITS_, INT_BITS_1 >
::maxval, QMODE, OMODE > 
operator| (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed
< Template_Max_Total_Bits
< TOTAL_BITS_, INT_BITS_,
TOTAL_BITS_1, INT_BITS_1 >
::maxval, Template_Max
< INT_BITS_, INT_BITS_1 >
::maxval, QMODE, OMODE > 
operator& (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed
< Template_Max_Total_Bits
< TOTAL_BITS_, INT_BITS_,
TOTAL_BITS_1, INT_BITS_1 >
::maxval, Template_Max
< INT_BITS_, INT_BITS_1 >
::maxval, QMODE, OMODE > 
operator^ (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed< TOTAL_BITS_+W,
INT_BITS_+W, QMODE, OMODE > 
operator<< (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_uint< W > &shift)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed< TOTAL_BITS_+W,
INT_BITS_+W, QMODE, OMODE > 
operator<< (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_int< W > &shift)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed< TOTAL_BITS_+W,
INT_BITS_+W, QMODE, OMODE > 
operator>> (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_uint< W > &shift)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed< TOTAL_BITS_+W,
INT_BITS_+W, QMODE, OMODE > 
operator>> (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_int< W > &shift)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed< TOTAL_BITS_,
INT_BITS_, QMODE, OMODE > 
operator>> (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const int &shift)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed< TOTAL_BITS_,
INT_BITS_, QMODE, OMODE > 
operator<< (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const int &shift)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator== (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator< (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator!= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator> (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator<= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator>= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const double &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const double &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const double &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const double &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const double &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const double &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const double &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const double &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const double &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const double &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const double &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const double &a)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const spuc_uint< W > &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const spuc_uint< W > &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const spuc_uint< W > &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const spuc_uint< W > &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const spuc_uint< W > &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const spuc_uint< W > &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const spuc_uint< W > &a)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const spuc_uint< W > &a)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const spuc_uint< W > &a)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const spuc_uint< W > &a)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const spuc_uint< W > &a)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const spuc_uint< W > &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const uint64_t &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const uint64_t &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const uint64_t &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const uint64_t &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const uint64_t &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const uint64_t &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const uint64_t &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const uint64_t &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const uint64_t &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const uint64_t &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const uint64_t &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const uint64_t &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const int &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const int &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const int &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const int &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const int &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const int &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const int &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const int &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const int &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const int &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const int &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const int &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator+ (const double &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 Math Operations. More...
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator+ (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b, const double &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator- (const double &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator- (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const double &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator* (const double &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator* (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const double &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator/ (const double &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator/ (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const double &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator+ (const int &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator+ (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b, const int &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator- (const int &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator- (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const int &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator* (const int &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator* (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const int &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator/ (const int &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator/ (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const int &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator+ (const uint64_t &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator+ (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b, const uint64_t &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator- (const uint64_t &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator- (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const uint64_t &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator* (const uint64_t &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator* (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const uint64_t &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator/ (const uint64_t &a, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator/ (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const uint64_t &b)
 
template<int NINT>
std::ostream & operator<< (std::ostream &os, const spuc_int< NINT > &r)
 
template<int NINT>
std::istream & operator>> (std::istream &os, const spuc_int< NINT > &r)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_,
W_1 >::maxval+1 > 
operator+ (const spuc_int< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_,
W_1 >::maxval+1 > 
operator- (const spuc_int< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< W_+W_1 > operator* (const spuc_int< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< W_ > operator/ (const spuc_int< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< W_+(1<< W_1)-1 > operator<< (const spuc_int< W_ > &a, const spuc_int< W_1 > &shift)
 
template<int W_, int W_1>
spuc_int< W_ > operator>> (const spuc_int< W_ > &a, const spuc_int< W_1 > &shift)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_,
W_1 >::maxval > 
operator| (const spuc_int< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_,
W_1 >::maxval > 
operator& (const spuc_int< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_,
W_1 >::maxval > 
operator^ (const spuc_int< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
bool operator== (const spuc_int< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
bool operator< (const spuc_int< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
bool operator!= (const spuc_int< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
bool operator> (const spuc_int< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
bool operator<= (const spuc_int< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
bool operator>= (const spuc_int< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_,
W_1+1 >::maxval+1 > 
operator+ (const spuc_int< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_+1,
W_1 >::maxval+1 > 
operator+ (const spuc_uint< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_,
W_1+1 >::maxval+1 > 
operator- (const spuc_int< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_+1,
W_1 >::maxval+1 > 
operator- (const spuc_uint< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< W_+W_1 > operator* (const spuc_int< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< W_+W_1 > operator* (const spuc_uint< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< W_+W_1 > operator/ (const spuc_uint< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< W_+W_1 > operator/ (const spuc_int< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< W_+(1<< W_1)-1 > operator<< (const spuc_int< W_ > &a, const spuc_uint< W_1 > &shift)
 
template<int W_, typename T_ >
spuc_int< W_ > operator<< (const spuc_int< W_ > &a, const T_ &shift)
 
template<int W_, typename T_ >
spuc_uint< W_ > operator<< (const spuc_uint< W_ > &a, const T_ &shift)
 
template<int W_, int W_1>
spuc_int< W_ > operator>> (const spuc_int< W_ > &a, const spuc_uint< W_1 > &shift)
 
template<int W_, typename T_ >
spuc_int< W_ > operator>> (const spuc_int< W_ > &a, const T_ &shift)
 
template<int W_, typename T_ >
spuc_uint< W_ > operator>> (const spuc_uint< W_ > &a, const T_ &shift)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_,
W_1 >::maxval > 
operator| (const spuc_int< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_,
W_1 >::maxval > 
operator| (const spuc_uint< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_,
W_1 >::maxval > 
operator& (const spuc_int< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_,
W_1 >::maxval > 
operator& (const spuc_uint< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_,
W_1 >::maxval > 
operator^ (const spuc_int< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
spuc_int< Template_Max< W_,
W_1 >::maxval > 
operator^ (const spuc_uint< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
bool operator== (const spuc_int< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
bool operator< (const spuc_int< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
bool operator!= (const spuc_int< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
bool operator> (const spuc_int< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
bool operator<= (const spuc_int< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
bool operator>= (const spuc_int< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
bool operator== (const spuc_uint< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
bool operator< (const spuc_uint< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
bool operator!= (const spuc_uint< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
bool operator> (const spuc_uint< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
bool operator<= (const spuc_uint< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_, int W_1>
bool operator>= (const spuc_uint< W_ > &a, const spuc_int< W_1 > &b)
 
template<int W_>
bool operator== (const double &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator!= (const double &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator< (const double &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator<= (const double &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator> (const double &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator>= (const double &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator== (const spuc_int< W_ > &b, const double &a)
 
template<int W_>
bool operator!= (const spuc_int< W_ > &b, const double &a)
 
template<int W_>
bool operator< (const spuc_int< W_ > &b, const double &a)
 
template<int W_>
bool operator<= (const spuc_int< W_ > &b, const double &a)
 
template<int W_>
bool operator> (const spuc_int< W_ > &b, const double &a)
 
template<int W_>
bool operator>= (const spuc_int< W_ > &b, const double &a)
 
template<int W_>
bool operator== (const uint64_t &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator!= (const uint64_t &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator< (const uint64_t &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator<= (const uint64_t &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator> (const uint64_t &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator>= (const uint64_t &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator== (const spuc_int< W_ > &b, const uint64_t &a)
 
template<int W_>
bool operator!= (const spuc_int< W_ > &b, const uint64_t &a)
 
template<int W_>
bool operator< (const spuc_int< W_ > &b, const uint64_t &a)
 
template<int W_>
bool operator<= (const spuc_int< W_ > &b, const uint64_t &a)
 
template<int W_>
bool operator> (const spuc_int< W_ > &b, const uint64_t &a)
 
template<int W_>
bool operator>= (const spuc_int< W_ > &b, const uint64_t &a)
 
template<int W_>
bool operator== (const int &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator!= (const int &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator< (const int &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator<= (const int &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator> (const int &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator>= (const int &a, const spuc_int< W_ > &b)
 
template<int W_>
bool operator== (const spuc_int< W_ > &b, const int &a)
 
template<int W_>
bool operator!= (const spuc_int< W_ > &b, const int &a)
 
template<int W_>
bool operator< (const spuc_int< W_ > &b, const int &a)
 
template<int W_>
bool operator<= (const spuc_int< W_ > &b, const int &a)
 
template<int W_>
bool operator> (const spuc_int< W_ > &b, const int &a)
 
template<int W_>
bool operator>= (const spuc_int< W_ > &b, const int &a)
 
template<int W_>
double operator+ (const double &a, const spuc_int< W_ > &b)
 
template<int W_>
double operator+ (const spuc_int< W_ > &b, const double &a)
 
template<int W_>
double operator- (const double &a, const spuc_int< W_ > &b)
 
template<int W_>
double operator- (const spuc_int< W_ > &a, const double &b)
 
template<int W_>
double operator* (const double &a, const spuc_int< W_ > &b)
 
template<int W_>
double operator* (const spuc_int< W_ > &a, const double &b)
 
template<int W_>
double operator/ (const double &a, const spuc_int< W_ > &b)
 
template<int W_>
double operator/ (const spuc_int< W_ > &a, const double &b)
 
template<int W_>
double operator+ (const int &a, const spuc_int< W_ > &b)
 
template<int W_>
double operator+ (const spuc_int< W_ > &b, const int &a)
 
template<int W_>
double operator- (const int &a, const spuc_int< W_ > &b)
 
template<int W_>
double operator- (const spuc_int< W_ > &a, const int &b)
 
template<int W_>
double operator* (const int &a, const spuc_int< W_ > &b)
 
template<int W_>
double operator* (const spuc_int< W_ > &a, const int &b)
 
template<int W_>
double operator/ (const int &a, const spuc_int< W_ > &b)
 
template<int W_>
double operator/ (const spuc_int< W_ > &a, const int &b)
 
template<int W_>
double operator+ (const uint64_t &a, const spuc_int< W_ > &b)
 
template<int W_>
double operator+ (const spuc_int< W_ > &b, const uint64_t &a)
 
template<int W_>
double operator- (const uint64_t &a, const spuc_int< W_ > &b)
 
template<int W_>
double operator- (const spuc_int< W_ > &a, const uint64_t &b)
 
template<int W_>
double operator* (const uint64_t &a, const spuc_int< W_ > &b)
 
template<int W_>
double operator* (const spuc_int< W_ > &a, const uint64_t &b)
 
template<int W_>
double operator/ (const uint64_t &a, const spuc_int< W_ > &b)
 
template<int W_>
double operator/ (const spuc_int< W_ > &a, const uint64_t &b)
 
template<int W_>
spuc_int< W_+1 > operator+ (const bool &a, const spuc_int< W_ > &b)
 
template<int W_>
spuc_int< W_+1 > operator+ (const spuc_int< W_ > &a, const bool &b)
 
template<int W_>
spuc_int< W_+1 > operator- (const bool &a, const spuc_int< W_ > &b)
 
template<int W_>
spuc_int< W_+1 > operator- (const spuc_int< W_ > &a, const bool &b)
 
std::string o_mode_string (spuc_o_mode O)
 
std::string q_mode_string (spuc_q_mode Q)
 
float_type sqrt (float_type x)
 sqrt More...
 
float_type cos (float_type x)
 
complex< float_typesqrt (complex< float_type > x)
 sqrt More...
 
complex< float_typesqrt (complex< long > x)
 sqrt More...
 
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_typecos (complex< float_type > x)
 
complex< float_typepolar (float_type amp, float_type arg)
 Polar to rectangular conversion. More...
 
complex< float_typeexp (complex< float_type > x)
 complex exponential More...
 
float_type hypot (complex< float_type > z)
 
complex< float > expj (float x)
 complex exponential More...
 
complex< double > expj (double x)
 
template<int T1, int I1, int T2, int I2, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed
< Template_Max_Total_Bits< T1,
I1, T2, I2 >::maxval+2,
Template_Max< I1, I2 >::maxval+2,
QMODE, OMODE > 
operator+ (const spuc_fixed< T1, I1, QMODE, OMODE > &a, const spuc_ufixed< T2, I2, QMODE1, OMODE1 > &b)
 
template<int T1, int I1, int T2, int I2, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed
< Template_Max_Total_Bits< T1,
I1, T2, I2 >::maxval+2,
Template_Max< I1, I2 >::maxval+2,
QMODE, OMODE > 
operator+ (const spuc_ufixed< T1, I1, QMODE, OMODE > &a, const spuc_fixed< T2, I2, QMODE1, OMODE1 > &b)
 
template<int T1, int I1, int T2, int I2, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed
< Template_Max_Total_Bits< T1,
I1, T2, I2 >::maxval+2,
Template_Max< I1, I2 >::maxval+2,
QMODE, OMODE > 
operator- (const spuc_fixed< T1, I1, QMODE, OMODE > &a, const spuc_ufixed< T2, I2, QMODE1, OMODE1 > &b)
 
template<int T1, int I1, int T2, int I2, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed
< Template_Max_Total_Bits< T1,
I1, T2, I2 >::maxval+2,
Template_Max< I1, I2 >::maxval+2,
QMODE, OMODE > 
operator- (const spuc_ufixed< T1, I1, QMODE, OMODE > &a, const spuc_fixed< T2, I2, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<(TOTAL_BITS_+TOTAL_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator* (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<(TOTAL_BITS_+TOTAL_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator* (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<(TOTAL_BITS_+TOTAL_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator/ (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_+INT_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator* (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_int< INT_BITS_1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_+INT_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator* (const spuc_int< INT_BITS_1 > &b, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a)
 
template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_+INT_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator* (const spuc_int< INT_BITS_1 > &b, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a)
 
template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_+INT_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator* (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_int< INT_BITS_1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_+INT_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator* (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_uint< INT_BITS_1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_+INT_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator* (const spuc_uint< INT_BITS_1 > &b, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a)
 
template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_+INT_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator* (const spuc_uint< INT_BITS_1 > &b, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a)
 
template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_+INT_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator* (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_uint< INT_BITS_1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator== (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator== (const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b, const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator< (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator< (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator!= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator!= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator> (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator> (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator<= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator<= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator>= (const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator>= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_ufixed
< Template_Max_Total_Bits
< TOTAL_BITS_, INT_BITS_,
TOTAL_BITS_1, INT_BITS_1 >
::maxval+1, Template_Max
< INT_BITS_, INT_BITS_1 >
::maxval+1, QMODE, OMODE > 
operator+ (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_ufixed
< Template_Max_Total_Bits
< TOTAL_BITS_, INT_BITS_,
TOTAL_BITS_1, INT_BITS_1 >
::maxval+1, Template_Max
< INT_BITS_, INT_BITS_1 >
::maxval+1, QMODE, OMODE > 
operator- (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_ufixed<(TOTAL_BITS_+TOTAL_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator* (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_ufixed<(TOTAL_BITS_+TOTAL_BITS_1),(INT_BITS_+INT_BITS_1),
QMODE, OMODE > 
operator/ (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_ufixed
< Template_Max_Total_Bits
< TOTAL_BITS_, INT_BITS_,
TOTAL_BITS_1, INT_BITS_1 >
::maxval, Template_Max
< INT_BITS_, INT_BITS_1 >
::maxval, QMODE, OMODE > 
operator| (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_ufixed
< Template_Max_Total_Bits
< TOTAL_BITS_, INT_BITS_,
TOTAL_BITS_1, INT_BITS_1 >
::maxval, Template_Max
< INT_BITS_, INT_BITS_1 >
::maxval, QMODE, OMODE > 
operator& (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_ufixed
< Template_Max_Total_Bits
< TOTAL_BITS_, INT_BITS_,
TOTAL_BITS_1, INT_BITS_1 >
::maxval, Template_Max
< INT_BITS_, INT_BITS_1 >
::maxval, QMODE, OMODE > 
operator^ (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_ufixed< TOTAL_BITS_+W,
INT_BITS_+W, QMODE, OMODE > 
operator<< (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_uint< W > &shift)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_ufixed< TOTAL_BITS_+W,
INT_BITS_+W, QMODE, OMODE > 
operator<< (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_int< W > &shift)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_ufixed< TOTAL_BITS_+W,
INT_BITS_+W, QMODE, OMODE > 
operator>> (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_uint< W > &shift)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_ufixed< TOTAL_BITS_+W,
INT_BITS_+W, QMODE, OMODE > 
operator>> (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_int< W > &shift)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_ufixed< TOTAL_BITS_,
INT_BITS_, QMODE, OMODE > 
operator>> (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const int &shift)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_ufixed< TOTAL_BITS_,
INT_BITS_, QMODE, OMODE > 
operator<< (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const int &shift)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator== (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator< (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator!= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator> (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator<= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool operator>= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const double &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const double &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const double &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const double &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const double &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const double &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const double &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const double &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const double &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const double &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const double &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const double &a)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const spuc_uint< W > &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const spuc_uint< W > &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const spuc_uint< W > &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const spuc_uint< W > &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const spuc_uint< W > &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const spuc_uint< W > &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const spuc_uint< W > &a)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const spuc_uint< W > &a)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const spuc_uint< W > &a)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const spuc_uint< W > &a)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const spuc_uint< W > &a)
 
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const spuc_uint< W > &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const uint64_t &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const uint64_t &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const uint64_t &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const uint64_t &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const uint64_t &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const uint64_t &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const uint64_t &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const uint64_t &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const uint64_t &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const uint64_t &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const uint64_t &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const uint64_t &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const int &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const int &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const int &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const int &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const int &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const int &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator== (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const int &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator!= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const int &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator< (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const int &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator<= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const int &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator> (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const int &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool operator>= (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &b, const int &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator+ (const double &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 Math Operations. More...
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator+ (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b, const double &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator- (const double &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator- (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const double &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator* (const double &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator* (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const double &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator/ (const double &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator/ (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const double &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator+ (const int &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator+ (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b, const int &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator- (const int &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator- (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const int &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator* (const int &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator* (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const int &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator/ (const int &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator/ (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const int &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator+ (const uint64_t &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator+ (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b, const uint64_t &a)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator- (const uint64_t &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator- (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const uint64_t &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator* (const uint64_t &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator* (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const uint64_t &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator/ (const uint64_t &a, const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &b)
 
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double operator/ (const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &a, const uint64_t &b)
 
template<int NINT>
std::ostream & operator<< (std::ostream &os, const spuc_uint< NINT > &r)
 
template<int NINT>
std::istream & operator>> (std::istream &os, const spuc_uint< NINT > &r)
 
template<int W_, int W_1>
spuc_uint< Template_Max< W_,
W_1 >::maxval+1 > 
operator+ (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
spuc_uint< Template_Max< W_,
W_1 >::maxval+1 > 
operator- (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
spuc_uint< W_+W_1 > operator* (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
spuc_uint< W_ > operator/ (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
spuc_uint< W_+(1<< W_1)-1 > operator<< (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &shift)
 
template<int W_, int W_1>
spuc_uint< W_ > operator>> (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &shift)
 
template<int W_, int W_1>
spuc_uint< Template_Max< W_,
W_1 >::maxval > 
operator| (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
spuc_uint< Template_Max< W_,
W_1 >::maxval > 
operator& (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
spuc_uint< Template_Max< W_,
W_1 >::maxval > 
operator^ (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
bool operator== (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
bool operator< (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
bool operator!= (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
bool operator> (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
bool operator<= (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &b)
 
template<int W_, int W_1>
bool operator>= (const spuc_uint< W_ > &a, const spuc_uint< W_1 > &b)
 
template<class T >
void toeplitz (vector< T > x, matrix< T > &A)
 Get Symmetric Toeplitz matrix from vector. More...
 
void remove_quotes (string &paramValStr)
 
void remove_path (string &in)
 
void remove_quotes (std::string &p)
 
void remove_path (std::string &in)
 
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 (std::vector< T > y)
 
template<class T >
void copy_vector (std::vector< T > x, std::vector< T > y)
 
std::ostream & operator<< (std::ostream &os, const self &r)
 
std::istream & operator>> (std::istream &is, self r)
 
vfloat operator<< (vfloat r, const natural shift)
 
vfloat operator>> (vfloat r, const natural shift)
 
std::ostream & operator<< (std::ostream &os, self r)
 
std::ostream & operator<< (std::ostream &os, vlog r)
 
std::istream & operator>> (std::istream &is, vlog r)
 
vlog operator- (const vlog &r)
 
vlog operator+ (const vlog &r, const vlog &l)
 
vlog operator- (const vlog &r, const vlog &l)
 
vlog operator* (const vlog &r, const vlog &l)
 
vlog operator/ (const vlog &r, const vlog &l)
 
vlog operator<< (const vlog &r, const long shift)
 
vlog operator>> (const vlog &r, const long shift)
 
float_type io (float_type x)
 bessel function for kaiser window More...
 
std::vector< float_typehamming (long nf, float_type alpha, float_type beta)
 hamming window $ w(n) = alpha + beta*cos( 2*\pi*(n-1)/(nf-1) )$ More...
 
std::vector< float_typehanning (long nf)
 hanning window $ w(n) = 0.5( 1 - cos( 2*\pi*n/(nf-1) )$ More...
 
std::vector< float_typeblackman (long nf)
 Blackman Window $ w[x] = 0.42 - 0.5*cos(2*\pi*x/nf) + 0.08*cos(2*\pi*x/nf)$. More...
 
std::vector< float_typekaiser (long nf, float_type beta)
 kaiser window More...
 
std::vector< float_typecheby (long nf, long n, long ieo, float_type dp, float_type df, float_type x0)
 dolph chebyshev window design More...
 
void chebc (float_type nf, float_type dp, float_type df, float_type n, float_type x0)
 chebyshev window subroutine to generate chebyshev window parameters when one of the three parameters nf,dp and df is unspecified??? More...
 

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
 
const int AP_ORDER =4
 
const int MAX_BANDS = 10
 
const int MIN_BANDS = 3
 

Detailed Description

fixed point types: spuc_fixed,spuc_ufixed,spuc_int,spuc_uint

Author
Tony Kirke

Typedef Documentation

typedef complex<double> SPUC::complex_d
typedef complex<builtin<double> > SPUC::complex_D
typedef complex<float> SPUC::complex_f
typedef complex<builtin<float> > SPUC::complex_F
typedef complex<int> SPUC::complex_i
typedef complex<long int> SPUC::complex_l
typedef complex<builtin<long int> > SPUC::complex_L
typedef builtin<double> SPUC::Double
typedef builtin<float> SPUC::Float
typedef double SPUC::float_type
typedef builtin<int> SPUC::Int
typedef builtin<long> SPUC::Long
typedef long long SPUC::long_long
typedef int64_t SPUC::max_int_type

Possible ranges for bit-widths.

typedef uint64_t SPUC::max_uint_type
typedef long SPUC::natural
typedef vlog SPUC::self

Enumeration Type Documentation

Similar to Systemc enums.

Enumerator
SPUC_SAT 
SPUC_SAT_SYM 
SPUC_WRAP 
Enumerator
SPUC_RND 
SPUC_TRN 

Function Documentation

template<typename T >
T SPUC::ABS ( a)
template<typename T >
T SPUC::approx_mag ( complex< T >  x)
inline

Approximate magnitude function.

References ABS(), SPUC::complex< T >::im, MAX(), MIN(), and SPUC::complex< T >::re.

Here is the call graph for this function:

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

Type Specific functions.

Return phase angle (radians) of complex number

References PI, and TWOPI.

Referenced by butterworth_s(), chebyshev_s(), SPUC::vco< Numeric >::clock(), SPUC::bpe< Numeric, Coeff >::clock(), SPUC::bpe< Numeric, Coeff >::fq_angle(), main(), and sqrt().

void SPUC::butterworth_s ( std::vector< complex< float_type > > &  poles,
std::vector< complex< float_type > > &  zeros,
bool  lpf,
float_type  wp,
long  n,
long  n2 
)

Calculate roots.

References arg(), expj(), and PI.

Referenced by butterworth_iir().

Here is the call graph for this function:

template<typename T >
double SPUC::calc_angle ( const complex< T >  x)
inline

References PI, and TWOPI.

void SPUC::chebyshev_s ( std::vector< complex< float_type > > &  poles,
std::vector< complex< float_type > > &  zeros,
bool  lpf,
float_type  wp,
float_type  epi,
long  n,
long  n2 
)

Calculate poles (chebyshev)

References arg(), cos(), cosh(), PI, sinh(), and sqrt().

Referenced by chebyshev_iir().

Here is the call graph for this function:

void SPUC::cic_freq ( int  rate,
int  order,
int  pts,
double *  w,
int  freq_off,
double  inc 
)

References magsq(), and PI.

Here is the call graph for this function:

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.

References SPUC::complex< T >::im, and SPUC::complex< T >::re.

template<class T >
void SPUC::copy_vector ( std::vector< T >  x,
std::vector< T >  y 
)
inline
void SPUC::create_remez_fir ( fir_coeff< float_type > &  remezfir,
int  jtype,
int  nbands,
std::vector< float_type >  edge,
std::vector< float_type >  fx,
std::vector< float_type >  wtx 
)

References SPUC::fir_coeff< Numeric >::num_taps, SPUC::remez_fir::remez(), and SPUC::fir_coeff< Numeric >::settap().

Here is the call graph for this function:

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

Dummy functions for library instantations.

int SPUC::dummy_vf ( void  )

References get_taps().

Here is the call graph for this function:

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

References SPUC::vector< T >::size().

Here is the call graph for this function:

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

References SPUC::vector< T >::size().

Here is the call graph for this function:

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

References SPUC::vector< T >::size().

Here is the call graph for this function:

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

References cos(), PI, and sqrt().

Referenced by elliptic_allpass(), and lamda_plane().

Here is the call graph for this function:

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

References ABS(), cos(), MACHEP, and sqrt().

Referenced by elliptic_allpass(), and s_plane().

Here is the call graph for this function:

float_type SPUC::ellpk ( float_type  k)

References PI, and sqrt().

Referenced by elliptic_iir(), and lamda_plane().

Here is the call graph for this function:

complex<float> SPUC::expj ( float  x)
inline

complex exponential

References cos().

Referenced by butterworth_s(), cheby(), SPUC::vco< Numeric >::clock(), dft(), exp(), fft(), freqz_mag_point(), idft(), ifft(), main(), ptr_freqz_mag_point(), and SPUC::baud_eq_env< Numeric >::step().

Here is the call graph for this function:

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

References cos().

Here is the call graph for this function:

template<typename T >
void SPUC::filt_freq ( T &  MF,
int  pts,
int  bits,
double *  w 
)

References PI.

double SPUC::find_a ( bool  hpf,
double  f,
double  des_gain,
double  h,
double  l 
)

References z_freqz_db().

Referenced by SPUC::shelf_allpass1< Numeric, Coeff >::set_coeffs().

Here is the call graph for this function:

template<typename T >
void SPUC::fir_freq ( T &  MF,
int  pts,
double *  w,
int  freq_off,
double  inc 
)

References cos(), magsq(), PI, and sqrt().

Here is the call graph for this function:

template<class Numeric , class Coeff >
std::vector<Numeric> SPUC::get_input ( const fir< Numeric, Coeff > &  f)
template<class T >
std::vector<T> SPUC::get_taps ( fir_coeff< T >  f)
template<class Numeric , class Coeff >
std::vector<Coeff> SPUC::get_taps ( const fir< Numeric, Coeff > &  f)
template<typename T >
void SPUC::iir_freq ( T &  MF,
bool  hpf,
int  pts,
int  bits,
double *  w,
int  freq_off,
double  inc 
)

References PI.

std::vector< float_type > SPUC::inv_dft ( const std::vector< float_type > &  A,
int  N 
)

calculates fir filter coefficients based on frequency sampling design using IDFT

References M, PI, and TWOPI.

Referenced by SPUC::remez_fir::remez().

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

get roots in Lamda plane

References ellik(), ellpk(), and msqrt().

Referenced by elliptic_iir().

Here is the call graph for this function:

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

Magnitude Squared of complex vector (also norm)

References ASP_C, hcadd_count, and hcmult_count.

template<typename T >
T SPUC::MAX ( a,
b 
)
template<typename T >
T SPUC::MIN ( a,
b 
)
float_type SPUC::msqrt ( float_type  u)

modulus from ratio of K/K'

References exp(), PI, and sqrt().

Referenced by elliptic_iir(), and lamda_plane().

Here is the call graph for this function:

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

Magnitude Squared of complex vector (also magnitude_squared)

References ASP_C, hcadd_count, and hcmult_count.

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

Normalized vector (magnitude = 1)

References SPUC::complex< T >::im, SPUC::complex< T >::re, and sqrt().

Referenced by freqz_point(), and ptr_freqz_point().

Here is the call graph for this function:

float_type SPUC::notch_example ( float_type  x)
std::string SPUC::o_mode_string ( spuc_o_mode  O)
inline

References SPUC_SAT, SPUC_SAT_SYM, and SPUC_WRAP.

template<class T >
builtin<T> SPUC::operator! ( const builtin< T > &  bi)
inline
template<typename T1 , typename T2 >
bool SPUC::operator!= ( complex< T1 >  r,
complex< T2 >  l 
)
inline
template<int W_, int W_1>
bool SPUC::operator!= ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator!= ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator!= ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator!= ( const spuc_uint< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_>
bool SPUC::operator!= ( const double &  a,
const spuc_int< W_ > &  b 
)

References SPUC::spuc_int< I_ >::to_double().

Here is the call graph for this function:

template<class T >
bool SPUC::operator!= ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
)
inline
template<int W_>
bool SPUC::operator!= ( const spuc_int< W_ > &  b,
const double &  a 
)

References SPUC::spuc_int< I_ >::to_double().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator!= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_>
bool SPUC::operator!= ( const uint64_t &  a,
const spuc_int< W_ > &  b 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator!= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_>
bool SPUC::operator!= ( const spuc_int< W_ > &  b,
const uint64_t &  a 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int W_>
bool SPUC::operator!= ( const int &  a,
const spuc_int< W_ > &  b 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator!= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const double &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W_>
bool SPUC::operator!= ( const spuc_int< W_ > &  b,
const int &  a 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator!= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const double &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const double &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const double &  a 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const spuc_uint< W > &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const spuc_uint< W > &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const spuc_uint< W > &  a 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const spuc_uint< W > &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const uint64_t &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const uint64_t &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const int &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const int &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const int &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator!= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const int &  a 
)
template<int W_, int W_1>
spuc_uint<Template_Max<W_, W_1>::maxval> SPUC::operator& ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
spuc_int<Template_Max<W_, W_1>::maxval> SPUC::operator& ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<Template_Max_Total_Bits<TOTAL_BITS_, INT_BITS_, TOTAL_BITS_1, INT_BITS_1>::maxval, Template_Max<INT_BITS_, INT_BITS_1>::maxval, QMODE, OMODE> SPUC::operator& ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_ufixed<Template_Max_Total_Bits<TOTAL_BITS_, INT_BITS_, TOTAL_BITS_1, INT_BITS_1>::maxval, Template_Max<INT_BITS_, INT_BITS_1>::maxval, QMODE, OMODE> SPUC::operator& ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_, int W_1>
spuc_int<Template_Max<W_, W_1>::maxval> SPUC::operator& ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
spuc_int<Template_Max<W_, W_1>::maxval> SPUC::operator& ( const spuc_uint< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template matrix<double> SPUC::operator* ( const matrix< double > &  m,
double  t 
)
template matrix<double> SPUC::operator* ( double  t,
const matrix< double > &  m 
)
template<int W_, int W_1>
spuc_int<W_ + W_1> SPUC::operator* ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  b 
)

References SPUC::spuc_int< I_ >::getVal(), SPUC::spuc_uint< I_ >::getVal(), and SPUC::spuc_int< I_ >::val.

Here is the call graph for this function:

template<int W_, int W_1>
spuc_uint<W_ + W_1> SPUC::operator* ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
spuc_int<W_ + W_1> SPUC::operator* ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_, int W_1>
spuc_int<W_ + W_1> SPUC::operator* ( const spuc_uint< W_ > &  a,
const spuc_int< W_1 > &  b 
)

References SPUC::spuc_uint< I_ >::getVal(), SPUC::spuc_int< I_ >::getVal(), and SPUC::spuc_int< I_ >::val.

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<(TOTAL_BITS_ + TOTAL_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator* ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<(TOTAL_BITS_ + TOTAL_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator* ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_ufixed<(TOTAL_BITS_ + TOTAL_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator* ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<class T >
vector<T> SPUC::operator* ( const vector< T > &  v,
const T  t 
)
inline

References SPUC::vector< T >::size().

Here is the call graph for this function:

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

References SPUC::vector< T >::size().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<(TOTAL_BITS_ + TOTAL_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator* ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<class T >
vector<T> SPUC::operator* ( const vector< T > &  v1,
const vector< T > &  v2 
)
inline

References SPUC::vector< T >::size().

Here is the call graph for this function:

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

References SPUC::matrix< T >::num_cols(), and SPUC::matrix< T >::num_rows().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_ + INT_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator* ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_int< INT_BITS_1 > &  b 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

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

References SPUC::matrix< T >::num_cols(), and SPUC::matrix< T >::num_rows().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_ + INT_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator* ( const spuc_int< INT_BITS_1 > &  b,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_ + INT_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator* ( const spuc_int< INT_BITS_1 > &  b,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a 
)
template<class T >
vector<T> SPUC::operator* ( const vector< T > &  v,
const matrix< T > &  m 
)
inline

References SPUC::matrix< T >::num_cols(), and SPUC::matrix< T >::num_rows().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_ + INT_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator* ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_int< INT_BITS_1 > &  b 
)
template<class T >
matrix<T> SPUC::operator* ( const matrix< T > &  m,
t 
)
inline

References SPUC::matrix< T >::num_cols(), and SPUC::matrix< T >::num_rows().

Here is the call graph for this function:

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

References SPUC::matrix< T >::num_cols(), and SPUC::matrix< T >::num_rows().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_ + INT_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator* ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_uint< INT_BITS_1 > &  b 
)

References SPUC::spuc_uint< I_ >::to_int().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_ + INT_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator* ( const spuc_uint< INT_BITS_1 > &  b,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a 
)

References SPUC::spuc_uint< I_ >::to_int().

Here is the call graph for this function:

vlog SPUC::operator* ( const vlog &  r,
const vlog &  l 
)
inline

References ABS(), SPUC::vlog::frac, SPUC::vlog::intlog, and SPUC::vlog::sign.

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_ + INT_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator* ( const spuc_uint< INT_BITS_1 > &  b,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, int INT_BITS_1, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<(TOTAL_BITS_ + INT_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator* ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_uint< INT_BITS_1 > &  b 
)
template<class T >
builtin<T> SPUC::operator* ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
)
inline
template<int W_>
double SPUC::operator* ( const double &  a,
const spuc_int< W_ > &  b 
)
template<int W_>
double SPUC::operator* ( const spuc_int< W_ > &  a,
const double &  b 
)
template<int W_>
double SPUC::operator* ( const int &  a,
const spuc_int< W_ > &  b 
)
template<int W_>
double SPUC::operator* ( const spuc_int< W_ > &  a,
const int &  b 
)
template<int W_>
double SPUC::operator* ( const uint64_t &  a,
const spuc_int< W_ > &  b 
)
template<int W_>
double SPUC::operator* ( const spuc_int< W_ > &  a,
const uint64_t &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator* ( const double &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator* ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const double &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator* ( const double &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator* ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const double &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator* ( const int &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator* ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const int &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator* ( const int &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator* ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const int &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator* ( const uint64_t &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator* ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const uint64_t &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator* ( const uint64_t &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator* ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const uint64_t &  b 
)
template<int W_, int W_1>
spuc_int<Template_Max<W_, W_1 + 1>::maxval + 1> SPUC::operator+ ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int T1, int I1, int T2, int I2, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<Template_Max_Total_Bits<T1, I1, T2, I2>::maxval + 2, Template_Max<I1, I2>::maxval + 2, QMODE, OMODE> SPUC::operator+ ( const spuc_fixed< T1, I1, QMODE, OMODE > &  a,
const spuc_ufixed< T2, I2, QMODE1, OMODE1 > &  b 
)
template<int W_, int W_1>
spuc_int<Template_Max<W_ + 1, W_1>::maxval + 1> SPUC::operator+ ( const spuc_uint< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<class T >
matrix<T> SPUC::operator+ ( const matrix< T > &  m1,
const matrix< T > &  m2 
)
inline

References SPUC::matrix< T >::num_cols(), and SPUC::matrix< T >::num_rows().

Here is the call graph for this function:

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

References SPUC::vector< T >::size().

Here is the call graph for this function:

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<int W_, int W_1>
spuc_int<Template_Max<W_, W_1>::maxval + 1> SPUC::operator+ ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_, int W_1>
spuc_uint<Template_Max<W_, W_1>::maxval + 1> SPUC::operator+ ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int T1, int I1, int T2, int I2, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<Template_Max_Total_Bits<T1, I1, T2, I2>::maxval + 2, Template_Max<I1, I2>::maxval + 2, QMODE, OMODE> SPUC::operator+ ( const spuc_ufixed< T1, I1, QMODE, OMODE > &  a,
const spuc_fixed< T2, I2, QMODE1, OMODE1 > &  b 
)
template<class T >
matrix<T> SPUC::operator+ ( const matrix< T > &  m,
t 
)
inline

References SPUC::matrix< T >::num_cols(), and SPUC::matrix< T >::num_rows().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<Template_Max_Total_Bits<TOTAL_BITS_, INT_BITS_, TOTAL_BITS_1, INT_BITS_1>::maxval + 1, Template_Max<INT_BITS_, INT_BITS_1>::maxval + 1, QMODE, OMODE> SPUC::operator+ ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_ufixed<Template_Max_Total_Bits<TOTAL_BITS_, INT_BITS_, TOTAL_BITS_1, INT_BITS_1>::maxval + 1, Template_Max<INT_BITS_, INT_BITS_1>::maxval + 1, QMODE, OMODE> SPUC::operator+ ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<class T >
matrix<T> SPUC::operator+ ( t,
const matrix< T > &  m 
)
inline

References SPUC::matrix< T >::num_cols(), and SPUC::matrix< T >::num_rows().

Here is the call graph for this function:

vlog SPUC::operator+ ( const vlog &  r,
const vlog &  l 
)
inline
template<class T >
builtin<T> SPUC::operator+ ( const builtin< T > &  bi)
inline
template<class T >
builtin<T> SPUC::operator+ ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
)
inline
template<int W_>
double SPUC::operator+ ( const double &  a,
const spuc_int< W_ > &  b 
)
template<int W_>
double SPUC::operator+ ( const spuc_int< W_ > &  b,
const double &  a 
)
template<int W_>
double SPUC::operator+ ( const int &  a,
const spuc_int< W_ > &  b 
)
template<int W_>
double SPUC::operator+ ( const spuc_int< W_ > &  b,
const int &  a 
)
template<int W_>
double SPUC::operator+ ( const uint64_t &  a,
const spuc_int< W_ > &  b 
)
template<int W_>
double SPUC::operator+ ( const spuc_int< W_ > &  b,
const uint64_t &  a 
)
template<int W_>
spuc_int<W_ + 1> SPUC::operator+ ( const bool &  a,
const spuc_int< W_ > &  b 
)
template<int W_>
spuc_int<W_ + 1> SPUC::operator+ ( const spuc_int< W_ > &  a,
const bool &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator+ ( const double &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)

Math Operations.

template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator+ ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b,
const double &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator+ ( const double &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)

Math Operations.

template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator+ ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b,
const double &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator+ ( const int &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator+ ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b,
const int &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator+ ( const int &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator+ ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b,
const int &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator+ ( const uint64_t &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator+ ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator+ ( const uint64_t &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator+ ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b,
const uint64_t &  a 
)
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<int W_, int W_1>
spuc_int<Template_Max<W_, W_1 + 1>::maxval + 1> SPUC::operator- ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template matrix<double> SPUC::operator- ( double  t,
const matrix< double > &  m 
)
template matrix<double> SPUC::operator- ( const matrix< double > &  m)
template<int W_, int W_1>
spuc_int<Template_Max<W_, W_1>::maxval + 1> SPUC::operator- ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_, int W_1>
spuc_int<Template_Max<W_ + 1, W_1>::maxval + 1> SPUC::operator- ( const spuc_uint< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_, int W_1>
spuc_uint<Template_Max<W_, W_1>::maxval + 1> SPUC::operator- ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int T1, int I1, int T2, int I2, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<Template_Max_Total_Bits<T1, I1, T2, I2>::maxval + 2, Template_Max<I1, I2>::maxval + 2, QMODE, OMODE> SPUC::operator- ( const spuc_fixed< T1, I1, QMODE, OMODE > &  a,
const spuc_ufixed< T2, I2, QMODE1, OMODE1 > &  b 
)
template<class T >
vector<T> SPUC::operator- ( const vector< T > &  v1,
const vector< T > &  v2 
)
inline

References SPUC::vector< T >::size().

Here is the call graph for this function:

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

References SPUC::matrix< T >::num_cols(), and SPUC::matrix< T >::num_rows().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<Template_Max_Total_Bits<TOTAL_BITS_, INT_BITS_, TOTAL_BITS_1, INT_BITS_1>::maxval + 1, Template_Max<INT_BITS_, INT_BITS_1>::maxval + 1, QMODE, OMODE> SPUC::operator- ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int T1, int I1, int T2, int I2, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<Template_Max_Total_Bits<T1, I1, T2, I2>::maxval + 2, Template_Max<I1, I2>::maxval + 2, QMODE, OMODE> SPUC::operator- ( const spuc_ufixed< T1, I1, QMODE, OMODE > &  a,
const spuc_fixed< T2, I2, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_ufixed<Template_Max_Total_Bits<TOTAL_BITS_, INT_BITS_, TOTAL_BITS_1, INT_BITS_1>::maxval + 1, Template_Max<INT_BITS_, INT_BITS_1>::maxval + 1, QMODE, OMODE> SPUC::operator- ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<class T >
vector<T> SPUC::operator- ( const vector< T > &  v)
inline

References SPUC::vector< T >::size().

Here is the call graph for this function:

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

References SPUC::matrix< T >::num_cols(), and SPUC::matrix< T >::num_rows().

Here is the call graph for this function:

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

References SPUC::matrix< T >::num_cols(), and SPUC::matrix< T >::num_rows().

Here is the call graph for this function:

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

References SPUC::matrix< T >::num_cols(), and SPUC::matrix< T >::num_rows().

Here is the call graph for this function:

vlog SPUC::operator- ( const vlog &  r)
inline

References SPUC::vlog::frac.

vlog SPUC::operator- ( const vlog &  r,
const vlog &  l 
)
inline
template<class T >
builtin<T> SPUC::operator- ( const builtin< T > &  bi)
inline
template<class T >
builtin<T> SPUC::operator- ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
)
inline
template<int W_>
double SPUC::operator- ( const double &  a,
const spuc_int< W_ > &  b 
)
template<int W_>
double SPUC::operator- ( const spuc_int< W_ > &  a,
const double &  b 
)
template<int W_>
double SPUC::operator- ( const int &  a,
const spuc_int< W_ > &  b 
)
template<int W_>
double SPUC::operator- ( const spuc_int< W_ > &  a,
const int &  b 
)
template<int W_>
double SPUC::operator- ( const uint64_t &  a,
const spuc_int< W_ > &  b 
)
template<int W_>
double SPUC::operator- ( const spuc_int< W_ > &  a,
const uint64_t &  b 
)
template<int W_>
spuc_int<W_ + 1> SPUC::operator- ( const bool &  a,
const spuc_int< W_ > &  b 
)
template<int W_>
spuc_int<W_ + 1> SPUC::operator- ( const spuc_int< W_ > &  a,
const bool &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator- ( const double &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator- ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const double &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator- ( const double &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator- ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const double &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator- ( const int &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator- ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const int &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator- ( const int &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator- ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const int &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator- ( const uint64_t &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator- ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const uint64_t &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator- ( const uint64_t &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator- ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const uint64_t &  b 
)
template<int W_, int W_1>
spuc_uint<W_> SPUC::operator/ ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
spuc_int<W_> SPUC::operator/ ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_, int W_1>
spuc_int<W_ + W_1> SPUC::operator/ ( const spuc_uint< W_ > &  a,
const spuc_int< W_1 > &  b 
)

References SPUC::spuc_uint< I_ >::getVal(), SPUC::spuc_int< I_ >::getVal(), and SPUC::spuc_int< I_ >::val.

Here is the call graph for this function:

template<int W_, int W_1>
spuc_int<W_ + W_1> SPUC::operator/ ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  b 
)

References SPUC::spuc_int< I_ >::getVal(), SPUC::spuc_uint< I_ >::getVal(), and SPUC::spuc_int< I_ >::val.

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<(TOTAL_BITS_ + TOTAL_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator/ ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_ufixed<(TOTAL_BITS_ + TOTAL_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator/ ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<(TOTAL_BITS_ + TOTAL_BITS_1), (INT_BITS_ + INT_BITS_1), QMODE, OMODE> SPUC::operator/ ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<class T >
vector<T> SPUC::operator/ ( const vector< T > &  v,
const T  t 
)
inline

References SPUC::vector< T >::size().

Here is the call graph for this function:

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

References SPUC::vector< T >::size().

Here is the call graph for this function:

vlog SPUC::operator/ ( const vlog &  r,
const vlog &  l 
)
inline

References ABS(), SPUC::vlog::frac, SPUC::vlog::intlog, and SPUC::vlog::sign.

Here is the call graph for this function:

template<class T >
builtin<T> SPUC::operator/ ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
)
inline
template<int W_>
double SPUC::operator/ ( const double &  a,
const spuc_int< W_ > &  b 
)
template<int W_>
double SPUC::operator/ ( const spuc_int< W_ > &  a,
const double &  b 
)
template<int W_>
double SPUC::operator/ ( const int &  a,
const spuc_int< W_ > &  b 
)
template<int W_>
double SPUC::operator/ ( const spuc_int< W_ > &  a,
const int &  b 
)
template<int W_>
double SPUC::operator/ ( const uint64_t &  a,
const spuc_int< W_ > &  b 
)
template<int W_>
double SPUC::operator/ ( const spuc_int< W_ > &  a,
const uint64_t &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator/ ( const double &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator/ ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const double &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator/ ( const double &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator/ ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const double &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator/ ( const int &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator/ ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const int &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator/ ( const int &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator/ ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const int &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator/ ( const uint64_t &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator/ ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const uint64_t &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator/ ( const uint64_t &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
double SPUC::operator/ ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const uint64_t &  b 
)
template<typename T1 , typename T2 >
bool SPUC::operator< ( complex< T1 >  r,
complex< T2 >  l 
)
inline

!

template<int W_, int W_1>
bool SPUC::operator< ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator< ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator< ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator< ( const spuc_uint< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_>
bool SPUC::operator< ( const double &  a,
const spuc_int< W_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator< ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<class T >
bool SPUC::operator< ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
)
inline
template<int W_>
bool SPUC::operator< ( const spuc_int< W_ > &  b,
const double &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator< ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_>
bool SPUC::operator< ( const uint64_t &  a,
const spuc_int< W_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator< ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_>
bool SPUC::operator< ( const spuc_int< W_ > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator< ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_>
bool SPUC::operator< ( const int &  a,
const spuc_int< W_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const double &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W_>
bool SPUC::operator< ( const spuc_int< W_ > &  b,
const int &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const double &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const double &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const double &  a 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const spuc_uint< W > &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const spuc_uint< W > &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const spuc_uint< W > &  a 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const spuc_uint< W > &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const uint64_t &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const uint64_t &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const int &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const int &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const int &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator< ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const int &  a 
)
template<int NINT>
std::ostream& SPUC::operator<< ( std::ostream &  os,
const spuc_uint< NINT > &  r 
)
template<int NINT>
std::ostream& SPUC::operator<< ( std::ostream &  os,
const spuc_int< NINT > &  r 
)
template<class T >
std::ostream & SPUC::operator<< ( std::ostream &  os,
const vector< T > &  v 
)
template<class T >
std::ostream& SPUC::operator<< ( std::ostream &  os,
complex< T >  r 
)

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

std::ostream& SPUC::operator<< ( std::ostream &  os,
const self &  r 
)
std::ostream & SPUC::operator<< ( std::ostream &  output,
const bit &  inbin 
)
std::ostream& SPUC::operator<< ( std::ostream &  os,
self  r 
)
template<typename T >
complex<T> SPUC::operator<< ( complex< T >  r,
const long  shift 
)
inline

Left shift (needs override for double)

References SPUC::complex< T >::im, and SPUC::complex< T >::re.

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

Left shift.

References SPUC::complex< T >::im, and SPUC::complex< T >::re.

template<int W_, int W_1>
spuc_int<W_ + (1 << W_1) - 1> SPUC::operator<< ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  shift 
)
template<int W_, int W_1>
spuc_uint<W_ + (1 << W_1) - 1> SPUC::operator<< ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  shift 
)
template<>
complex<float> SPUC::operator<< ( complex< float >  r,
const long  shift 
)
inline
template<int W_, int W_1>
spuc_int<W_ + (1 << W_1) - 1> SPUC::operator<< ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  shift 
)
template<int W_, typename T_ >
spuc_int<W_> SPUC::operator<< ( const spuc_int< W_ > &  a,
const T_ &  shift 
)
template<int W_, typename T_ >
spuc_uint<W_> SPUC::operator<< ( const spuc_uint< W_ > &  a,
const T_ &  shift 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<TOTAL_BITS_ + W, INT_BITS_ + W, QMODE, OMODE> SPUC::operator<< ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_uint< W > &  shift 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<TOTAL_BITS_ + W, INT_BITS_ + W, QMODE, OMODE> SPUC::operator<< ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_int< W > &  shift 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_ufixed<TOTAL_BITS_ + W, INT_BITS_ + W, QMODE, OMODE> SPUC::operator<< ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_uint< W > &  shift 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_ufixed<TOTAL_BITS_ + W, INT_BITS_ + W, QMODE, OMODE> SPUC::operator<< ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_int< W > &  shift 
)
std::ostream& SPUC::operator<< ( std::ostream &  os,
vlog  r 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<TOTAL_BITS_, INT_BITS_, QMODE, OMODE> SPUC::operator<< ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const int &  shift 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_ufixed<TOTAL_BITS_, INT_BITS_, QMODE, OMODE> SPUC::operator<< ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const int &  shift 
)
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,
long  i 
)
inline
vlog SPUC::operator<< ( const vlog &  r,
const long  shift 
)
inline

References SPUC::vlog::intlog.

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<float> SPUC::operator<< ( const builtin< float > &  bi,
int  i 
)
inline
template<>
builtin<float> SPUC::operator<< ( const builtin< float > &  bi,
long  i 
)
inline
template<typename T1 , typename T2 >
bool SPUC::operator<= ( complex< T1 >  r,
complex< T2 >  l 
)
inline

!

template<int W_, int W_1>
bool SPUC::operator<= ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator<= ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator<= ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator<= ( const spuc_uint< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_>
bool SPUC::operator<= ( const double &  a,
const spuc_int< W_ > &  b 
)
template<class T >
bool SPUC::operator<= ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
)
inline
template<int W_>
bool SPUC::operator<= ( const spuc_int< W_ > &  b,
const double &  a 
)
template<int W_>
bool SPUC::operator<= ( const uint64_t &  a,
const spuc_int< W_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator<= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_>
bool SPUC::operator<= ( const spuc_int< W_ > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator<= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_>
bool SPUC::operator<= ( const int &  a,
const spuc_int< W_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const double &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W_>
bool SPUC::operator<= ( const spuc_int< W_ > &  b,
const int &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const double &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const double &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator<= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const double &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator<= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const spuc_uint< W > &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const spuc_uint< W > &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const spuc_uint< W > &  a 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const spuc_uint< W > &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const uint64_t &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const uint64_t &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const int &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const int &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const int &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator<= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const int &  a 
)
template<typename T1 , typename T2 >
bool SPUC::operator== ( complex< T1 >  r,
complex< T2 >  l 
)
inline
template<int W_, int W_1>
bool SPUC::operator== ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator== ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator== ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator== ( const spuc_uint< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_>
bool SPUC::operator== ( const double &  a,
const spuc_int< W_ > &  b 
)

References SPUC::spuc_int< I_ >::to_double().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator== ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator== ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<class T >
bool SPUC::operator== ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
)
inline
template<int W_>
bool SPUC::operator== ( const spuc_int< W_ > &  b,
const double &  a 
)

References SPUC::spuc_int< I_ >::to_double().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator== ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator== ( const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a 
)
template<int W_>
bool SPUC::operator== ( const uint64_t &  a,
const spuc_int< W_ > &  b 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int W_>
bool SPUC::operator== ( const spuc_int< W_ > &  b,
const uint64_t &  a 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int W_>
bool SPUC::operator== ( const int &  a,
const spuc_int< W_ > &  b 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const double &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W_>
bool SPUC::operator== ( const spuc_int< W_ > &  b,
const int &  a 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const double &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const double &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const double &  a 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const spuc_uint< W > &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const spuc_uint< W > &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const spuc_uint< W > &  a 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const spuc_uint< W > &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const uint64_t &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const uint64_t &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const int &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const int &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const int &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator== ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const int &  a 
)
template<typename T1 , typename T2 >
bool SPUC::operator> ( complex< T1 >  r,
complex< T2 >  l 
)
inline

!

template<int W_, int W_1>
bool SPUC::operator> ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator> ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator> ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator> ( const spuc_uint< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_>
bool SPUC::operator> ( const double &  a,
const spuc_int< W_ > &  b 
)

References SPUC::spuc_int< I_ >::to_double().

Here is the call graph for this function:

template<int W_>
bool SPUC::operator> ( const spuc_int< W_ > &  b,
const double &  a 
)

References SPUC::spuc_int< I_ >::to_double().

Here is the call graph for this function:

template<class T >
bool SPUC::operator> ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
)
inline
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator> ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_>
bool SPUC::operator> ( const uint64_t &  a,
const spuc_int< W_ > &  b 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator> ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_>
bool SPUC::operator> ( const spuc_int< W_ > &  b,
const uint64_t &  a 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int W_>
bool SPUC::operator> ( const int &  a,
const spuc_int< W_ > &  b 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const double &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W_>
bool SPUC::operator> ( const spuc_int< W_ > &  b,
const int &  a 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator> ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const double &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator> ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const double &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const double &  a 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const spuc_uint< W > &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const spuc_uint< W > &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const spuc_uint< W > &  a 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const spuc_uint< W > &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const uint64_t &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const uint64_t &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const int &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const int &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const int &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator> ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const int &  a 
)
template<typename T1 , typename T2 >
bool SPUC::operator>= ( complex< T1 >  r,
complex< T2 >  l 
)
inline

!

template<int W_, int W_1>
bool SPUC::operator>= ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator>= ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator>= ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
bool SPUC::operator>= ( const spuc_uint< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_>
bool SPUC::operator>= ( const double &  a,
const spuc_int< W_ > &  b 
)

References SPUC::spuc_int< I_ >::to_double().

Here is the call graph for this function:

template<int W_>
bool SPUC::operator>= ( const spuc_int< W_ > &  b,
const double &  a 
)

References SPUC::spuc_int< I_ >::to_double().

Here is the call graph for this function:

template<class T >
bool SPUC::operator>= ( const builtin< T > &  bi1,
const builtin< T > &  bi2 
)
inline
template<int W_>
bool SPUC::operator>= ( const uint64_t &  a,
const spuc_int< W_ > &  b 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator>= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_>
bool SPUC::operator>= ( const spuc_int< W_ > &  b,
const uint64_t &  a 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator>= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_>
bool SPUC::operator>= ( const int &  a,
const spuc_int< W_ > &  b 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int W_>
bool SPUC::operator>= ( const spuc_int< W_ > &  b,
const int &  a 
)

References SPUC::spuc_int< I_ >::to_int().

Here is the call graph for this function:

template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const double &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const double &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const double &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const double &  a 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const spuc_uint< W > &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator>= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
bool SPUC::operator>= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const spuc_uint< W > &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const spuc_uint< W > &  a 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const spuc_uint< W > &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const uint64_t &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const uint64_t &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const uint64_t &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const int &  a,
const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const int &  a,
const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const int &  a 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE_, spuc_o_mode OMODE_>
bool SPUC::operator>= ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE_, OMODE_ > &  b,
const int &  a 
)
template<int NINT>
std::istream& SPUC::operator>> ( std::istream &  os,
const spuc_uint< NINT > &  r 
)
template<int NINT>
std::istream& SPUC::operator>> ( std::istream &  os,
const spuc_int< NINT > &  r 
)
template<class T >
std::istream& SPUC::operator>> ( std::istream &  os,
complex< T >  r 
)
std::istream & SPUC::operator>> ( std::istream &  is,
self  r 
)
std::istream & SPUC::operator>> ( std::istream &  input,
bit &  outbin 
)
template<typename T >
complex<T> SPUC::operator>> ( complex< T >  r,
const long  shift 
)
inline

Right shift (needs override for double)

References SPUC::complex< T >::im, and SPUC::complex< T >::re.

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

Right shift.

References SPUC::complex< T >::im, and SPUC::complex< T >::re.

template<int W_, int W_1>
spuc_uint<W_> SPUC::operator>> ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  shift 
)
template<int W_, int W_1>
spuc_int<W_> SPUC::operator>> ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  shift 
)
template<>
complex<float> SPUC::operator>> ( complex< float >  r,
const long  shift 
)
inline

Right shift.

References SPUC::complex< T >::im, and SPUC::complex< T >::re.

template<int W_, int W_1>
spuc_int<W_> SPUC::operator>> ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  shift 
)
template<int W_, typename T_ >
spuc_int<W_> SPUC::operator>> ( const spuc_int< W_ > &  a,
const T_ &  shift 
)
template<int W_, typename T_ >
spuc_uint<W_> SPUC::operator>> ( const spuc_uint< W_ > &  a,
const T_ &  shift 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<TOTAL_BITS_ + W, INT_BITS_ + W, QMODE, OMODE> SPUC::operator>> ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_uint< W > &  shift 
)
std::istream& SPUC::operator>> ( std::istream &  is,
vlog  r 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_ufixed<TOTAL_BITS_ + W, INT_BITS_ + W, QMODE, OMODE> SPUC::operator>> ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_uint< W > &  shift 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<TOTAL_BITS_ + W, INT_BITS_ + W, QMODE, OMODE> SPUC::operator>> ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_int< W > &  shift 
)
template<int W, int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_ufixed<TOTAL_BITS_ + W, INT_BITS_ + W, QMODE, OMODE> SPUC::operator>> ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_int< W > &  shift 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_fixed<TOTAL_BITS_, INT_BITS_, QMODE, OMODE> SPUC::operator>> ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const int &  shift 
)
template<int TOTAL_BITS_, int INT_BITS_, spuc_q_mode QMODE, spuc_o_mode OMODE>
spuc_ufixed<TOTAL_BITS_, INT_BITS_, QMODE, OMODE> SPUC::operator>> ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const int &  shift 
)
template<class T >
std::istream& SPUC::operator>> ( std::istream &  s,
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,
long  i 
)
inline
vlog SPUC::operator>> ( const vlog &  r,
const long  shift 
)
inline

References SPUC::vlog::intlog.

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<float> SPUC::operator>> ( const builtin< float > &  bi,
int  i 
)
inline
template<>
builtin<float> SPUC::operator>> ( const builtin< float > &  bi,
long  i 
)
inline
template<int W_, int W_1>
spuc_int<Template_Max<W_, W_1>::maxval> SPUC::operator^ ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_, int W_1>
spuc_uint<Template_Max<W_, W_1>::maxval> SPUC::operator^ ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<Template_Max_Total_Bits<TOTAL_BITS_, INT_BITS_, TOTAL_BITS_1, INT_BITS_1>::maxval, Template_Max<INT_BITS_, INT_BITS_1>::maxval, QMODE, OMODE> SPUC::operator^ ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_, int W_1>
spuc_int<Template_Max<W_, W_1>::maxval> SPUC::operator^ ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_ufixed<Template_Max_Total_Bits<TOTAL_BITS_, INT_BITS_, TOTAL_BITS_1, INT_BITS_1>::maxval, Template_Max<INT_BITS_, INT_BITS_1>::maxval, QMODE, OMODE> SPUC::operator^ ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_, int W_1>
spuc_int<Template_Max<W_, W_1>::maxval> SPUC::operator^ ( const spuc_uint< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int W_, int W_1>
spuc_uint<Template_Max<W_, W_1>::maxval> SPUC::operator| ( const spuc_uint< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
spuc_int<Template_Max<W_, W_1>::maxval> SPUC::operator| ( const spuc_int< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_fixed<Template_Max_Total_Bits<TOTAL_BITS_, INT_BITS_, TOTAL_BITS_1, INT_BITS_1>::maxval, Template_Max<INT_BITS_, INT_BITS_1>::maxval, QMODE, OMODE> SPUC::operator| ( const spuc_fixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_fixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int TOTAL_BITS_, int INT_BITS_, int TOTAL_BITS_1, int INT_BITS_1, spuc_q_mode QMODE, spuc_q_mode QMODE1, spuc_o_mode OMODE, spuc_o_mode OMODE1>
spuc_ufixed<Template_Max_Total_Bits<TOTAL_BITS_, INT_BITS_, TOTAL_BITS_1, INT_BITS_1>::maxval, Template_Max<INT_BITS_, INT_BITS_1>::maxval, QMODE, OMODE> SPUC::operator| ( const spuc_ufixed< TOTAL_BITS_, INT_BITS_, QMODE, OMODE > &  a,
const spuc_ufixed< TOTAL_BITS_1, INT_BITS_1, QMODE1, OMODE1 > &  b 
)
template<int W_, int W_1>
spuc_int<Template_Max<W_, W_1>::maxval> SPUC::operator| ( const spuc_int< W_ > &  a,
const spuc_uint< W_1 > &  b 
)
template<int W_, int W_1>
spuc_int<Template_Max<W_, W_1>::maxval> SPUC::operator| ( const spuc_uint< W_ > &  a,
const spuc_int< W_1 > &  b 
)
template<class T >
builtin<T> SPUC::operator~ ( const builtin< T > &  bi)
inline
template<typename T >
void SPUC::other_freq ( T &  AP,
int  pts,
double *  w,
int  freq_off,
double  inc 
)

References magsq(), PI, and polar().

Here is the call graph for this function:

template<typename T >
void SPUC::other_freq ( T &  AP,
int  pts,
double *  w 
)

References magsq(), PI, and polar().

Here is the call graph for this function:

std::string SPUC::q_mode_string ( spuc_q_mode  Q)
inline

References SPUC_RND, and SPUC_TRN.