|
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 > |
T | bpsk_dd_phase (complex< T > curr, complex< T > hard_data) |
| Decision directed carrier phase discriminator for BPSK. More...
|
|
template<class T > |
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 > |
T | magnitude_squared (complex< T > x) |
| Magnitude Squared of complex vector (also norm) More...
|
|
template<typename T > |
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 > |
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 > |
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 > |
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 > |
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_type > | inv_dft_symmetric (const std::vector< float_type > &A, int N) |
| Calculate coefficients for FIR using frequency sampling IDFT. More...
|
|
std::vector< float_type > | inv_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_type > | freqz_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_type > | freqz_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 > |
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_type > | ptr_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_type > | ptr_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 > |
T | qpsk_dd_phase (complex< T > curr, complex< T > hard_data) |
| Decision directed carrier phase discriminator for QPSK. More...
|
|
template<class T > |
T | qpsk_quadricorrelator (complex< T > hard_data, complex< T > prev) |
|
template<class T > |
T | qpsk_rcfd (complex< T > fmf, complex< T > curr) |
|
template<typename T > |
quantized_type< T >::dtype | quantize (T in) |
| Templated Quantize function template function that uses a class to allow template specialization. More...
|
|
template<typename T > |
T | quantize_scale (float_type x, float_type ox, T y) |
|
template<class T > |
void | raised_cosine (fir_coeff< T > &rcfir, float_type alpha, 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 > |
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 > |
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 > |
T | round (T in, long bits) |
| Templated round function template function that uses a class to allow template specialization. More...
|
|
template<class T > |
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 > |
T | signbit (T in) |
| Templated signbit function template function that uses a class to allow template specialization. More...
|
|
template<typename T > |
T | MAX (T a, T b) |
|
template<typename T > |
T | MIN (T a, T b) |
|
template<typename T > |
T | ABS (T a) |
|
template<typename T > |
T | SQR (T a) |
|
template<typename T > |
T | SGN (T a) |
|
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_type > | sqrt (complex< float_type > x) |
| sqrt More...
|
|
complex< float_type > | sqrt (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_type > | cos (complex< float_type > x) |
|
complex< float_type > | polar (float_type amp, float_type arg) |
| Polar to rectangular conversion. More...
|
|
complex< float_type > | exp (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 ¶mValStr) |
|
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_type > | hamming (long nf, float_type alpha, float_type beta) |
| hamming window More...
|
|
std::vector< float_type > | hanning (long nf) |
| hanning window More...
|
|
std::vector< float_type > | blackman (long nf) |
| Blackman Window . More...
|
|
std::vector< float_type > | kaiser (long nf, float_type beta) |
| kaiser window More...
|
|
std::vector< float_type > | cheby (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...
|
|