itpp Namespace Reference

itpp namespace More...

## Classes

class | ACK
class | ACK_Channel
| ADD DOCUMENTATION HERE. More...
class | AR1_Normal_RNG
| Filtered normal distribution. More...
class | AR_Filter
| Autoregressive (AR) Filter Base Class. More...
class | ARMA_Filter
| Autoregressive Moving Average (ARMA) Filter Base Class. More...
class | Array
| General array class. More...
class | Audio_Sample
| Generic template class for Audio samples. More...
class | Audio_Sample< enc_alaw8 >
| aLaw-encoded Audio samples. More...
class | Audio_Sample< enc_double >
| Audio samples encoded as doubles. More...
class | Audio_Sample< enc_float >
| Audio samples encoded as floats. More...
class | Audio_Sample< enc_linear16 >
| 16-bit PCM encoded audio samples More...
class | Audio_Sample< enc_linear24 >
| 24-bit PCM encoded audio samples. More...
class | Audio_Sample< enc_linear32 >
| 32-bit PCM encoded audio samples. More...
class | Audio_Sample< enc_linear8 >
| 8-bit PCM encoded audio samples. More...
class | Audio_Sample< enc_mulaw8 >
| uLaw-encoded Audio samples. More...
class | Audio_Stream_Description
| Description of audio stream. More...
class | AWGN_Channel
| Ordinary AWGN Channel for cvec or vec inputs and outputs. More...
class | Base_Event
| Base Event Class. More...
class | Base_Slot
| Base Slot class. More...
class | BCH
| Class for binary, narrow-sense BCH codes. More...
class | BERC
| Bit Error Rate Counter (BERC) Class. More...
class | Bernoulli_RNG
| Bernoulli distribution. More...
class | bfstream
| Binary in/out-file Class. More...
class | bfstream_base
| Base class for binary file classes. More...
class | bifstream
| Binary Infile Class. More...
class | bin
| Binary arithmetic (boolean) class. More...
class | BLDPC_Generator
| Block LDPC Generator class. More...
class | BLDPC_Parity
| Block LDPC code parity-check matrix. More...
class | BLERC
| Class for counting block error rates. More...
class | Block_Interleaver
| Block Interleaver Class. More...
class | bofstream
| Binary Outfile Class. More...
class | BPSK
| BPSK modulator with real symbols. More...
class | BPSK_c
| BPSK modulator with complex symbols. More...
class | BSC
| A Binary Symetric Channel with crossover probability p. More...
class | Burst_WWW_Packet_Generator
class | CFix
| Complex fixed-point data type. More...
class | CFixed
| Templated complex fixed-point data type. More...
class | Channel_Code
| Generic Channel Code class. More...
class | Channel_Specification
| General specification of a time-domain multipath channel. More...
class | Circular_Buffer
| General circular buffer class. More...
struct | Compare_Base_Event_Times
| Compare to events, Returns true if expire time of event1 is larger than the expire time of event2. More...
class | Complex_Normal_RNG
| A Complex Normal Source. More...
class | Constant_Rate_Packet_Generator
class | Convolutional_Code
| Binary Convolutional rate 1/n class. More...
class | Correlated_Fading_Generator
| Correlated (random) fading generator class. More...
class | CPU_Timer
| A CPU time timer class. More...
class | CRC_Code
| Cyclic Redundancy Check Codes. More...
class | Cross_Interleaver
| Cross Interleaver Class. More...
class | Data_Event
| An Event class that executes a function with some data as input when the event expires. More...
class | Dummy_Code
| Dummy Channel Code class. More...
class | Event
| An Event class that executes a function when the event expires. More...
class | Event_Queue
| Event Queue class. More...
class | EXIT
| EXtrinsic Information Transfer (EXIT) chart. More...
class | Exponential_RNG
| Exponential distribution. More...
class | Extended_Golay
| Extended Golay code (24,12,8). More...
class | Factory
| Base class for class factories. More...
class | Fading_Generator
| Fading generator class. More...
class | Fast_ICA
| Fast_ICA Fast Independent Component Analysis (Fast ICA) More...
class | Filter
| Virtual Filter Base Class. More...
class | FIR_Fading_Generator
| FIR type Fading generator class. More...
class | Fix
| Fixed-point data type. More...
class | Fix_Base
| Base class for fixed-point data types. More...
class | Fix_Factory
| Class factory for fixed-point data types Fix and CFix. More...
class | Fixed
| Templated fixed-point data type. More...
class | Freq_Filt
| Freq_Filt Frequency domain filtering using the overlap-add technique. More...
class | Front_Drop_Queue
| ADD DOCUMENTATION HERE. More...
class | Gamma_RNG
| Gamma distribution. More...
class | GF
| Galois Field GF(q). More...
class | GF2mat
| Class for dense GF(2) matrices. More...
class | GF2mat_sparse_alist
| Parameterized "alist" representation of sparse GF(2) matrix. More...
class | GFX
| Polynomials over GF(q)[x], where q=2^m, m=1,...,16. More...
class | GMM
| Gaussian Mixture Model Class. More...
class | Gold
| Gold Sequences. More...
class | Hamming_Code
| Binary Hamming codes. More...
class | Histogram
| Histogram computation class. More...
class | I_Uniform_RNG
| Integer uniform distribution. More...
class | IFFT_Fading_Generator
| IFFT type Fading generator class. More...
class | Impulse_Source
| Impulse source. More...
class | Independent_Fading_Generator
| Independent (random) fading generator class. More...
class | it_file
| The IT++ file format reading and writing class. More...
class | it_file_base
| Base class for it_ifile and it_file. More...
class | it_file_base_old
| Base class for it_ifile_old and it_file_old. More...
class | it_file_old
| The old (version 2) IT++ file format reading and writing class. More...
class | it_ifile
| The IT++ file format reading class. More...
class | it_ifile_old
| The old (version 2) IT++ file format reading class. More...
class | L3_Packet_Info
class | Laplace_RNG
| Laplacian distribution. More...
class | LDPC_Code
| Low-density parity check (LDPC) codec. More...
class | LDPC_Generator
| LDPC Generator pure virtual base class. More...
class | LDPC_Generator_Systematic
| Systematic LDPC Generator class. More...
class | LDPC_Parity
| LDPC parity check matrix generic class. More...
class | LDPC_Parity_Irregular
| Irregular LDPC code generator class. More...
class | LDPC_Parity_Regular
| Regular LDPC code generator class. More...
class | LDPC_Parity_Unstructured
| Pure abstract class for unstructured LDPC matrices. More...
class | LFSR
| Binary Linear Feedback Shift Register (LFSR) More...
class | Line_Search
| Line Search. More...
class | Link_Packet
class | LLR_calc_unit
| Log-likelihood algebra calculation unit. More...
class | MA_Filter
| Moving Average Filter Base Class. More...
class | Mat
| Matrix Class (Templated) More...
class | Modulator
| General modulator for 1D or 2D signal constellations. More...
class | Modulator_NCD
| Base class for vector (MIMO) channel modulator/demodulators with complex valued components. More...
class | Modulator_ND
| Base class for an N-dimensional (ND) vector (MIMO) modulator. More...
class | Modulator_NRD
| Base class for N-dimensional vector (MIMO) channel modulators/demodulators with real-valued components. More...
class | MOG_diag
| Diagonal Mixture of Gaussians (MOG) class. More...
class | MOG_diag_EM_sup
| support class for MOG_diag_ML() and MOG_diag_MAP() More...
class | MOG_diag_kmeans_sup
| support class for MOG_diag_kmeans() More...
class | MOG_generic
| Generic Mixture of Gaussians (MOG) class. Used as a base for other MOG classes. More...
class | Multicode_Spread_1d
| Multicode spreading of float symbols. More...
class | Multicode_Spread_2d
| Multicode spreading of complex symbols to complex output. More...
class | Multilateration
| Multilateration class for 3D indoor localization More...
class | Name
| Automatic naming when saving. More...
class | ND_UPAM
| Real-valued MIMO channel with uniform PAM along each dimension. More...
class | ND_UPSK
class | ND_UQAM
| Complex MIMO channel with uniform QAM per dimension. More...
class | Newton_Search
| Newton Search. More...
class | Normal_RNG
| Normal distribution. More...
class | OFDM
| Class for modulating and demodulation of OFDM signals using the FFT. More...
class | Packet
class | Packet_Channel
| ADD DOCUMENTATION HERE. More...
class | Packet_Generator
class | PAM
| M-ary PAM modulator with real symbols. More...
class | PAM_c
| M-ary PAM modulator with complex symbols. More...
class | Parser
| Argument Parser Class. More...
class | Pattern_Source
| Pattern source. More...
class | Poisson_Packet_Generator
class | PSK
| M-ary PSK modulator. More...
class | Pulse_Shape
| General FIR Pulse Shape. More...
class | Punctured_Convolutional_Code
| Binary Punctured Convolutional Code Class. More...
class | Punctured_Turbo_Codec
| Punctured turbo encoder/decoder Class. More...
class | QAM
| M-ary QAM modulator with square lattice. More...
class | QPSK
| QPSK modulator. More...
class | Raised_Cosine
| Raised Cosine (RC) Pulse Shaper. More...
class | Random_Generator
| Base class for random (stochastic) sources. More...
class | Rayleigh_RNG
| Rayleigh distribution. More...
class | Real_Timer
| A real time timer class. More...
class | Rec_Syst_Conv_Code
| A Recursive Systematic Convolutional Encoder/Decoder class. More...
class | Reed_Solomon
| Reed-Solomon Codes. More...
class | Rice_Fading_Generator
| Rice type fading generator class. More...
class | Rice_RNG
| Rice distribution. More...
class | Root_Raised_Cosine
| (Square) Root Raised Cosine (RRC) Pulse Shaper More...
class | Sample_24
| Small class to represent 24-bit PCM samples. More...
class | Sawtooth_Source
| Sawtooth-wave source. More...
class | Scalar_Quantizer
| Class for vector quantization. More...
class | Selective_Repeat_ARQ_Receiver
class | Selective_Repeat_ARQ_Sender
class | Sequence_Interleaver
| Sequence Interleaver Class. More...
class | Sequence_Number
class | Signal
| Signals and slots. More...
class | Sine_Source
| Sine-wave source. More...
class | Sink
class | SISO
| Soft Input Soft Output (SISO) modules. More...
class | Slot
| Slot Class. More...
class | SND_In_File
| Class to read audio data from au file. More...
class | SND_IO_File
| A class for doing both input and output of audio samples. More...
class | SND_Out_File
| A class to write SND-files (the .au format) More...
class | Sort
| Class for sorting of vectors. More...
class | Sparse_Mat
| Templated Sparse Matrix Class. More...
class | Sparse_Vec
| Templated sparse vector class. More...
class | Spread_1d
| Spreading of float symbols to float output. More...
class | Spread_2d
| Spreading of complex symbols to complex output. More...
class | Square_Source
| Square-wave source. More...
class | Stack
| General stack class. More...
class | Stat
| A class for sampling a signal and calculating statistics. More...
class | Static_Fading_Generator
| Static fading generator class. More...
class | STC
| Space Time block Codes (STC) class. More...
class | TCP_Client_Application
class | TCP_Packet
class | TCP_Receiver
class | TCP_Receiver_Buffer
class | TCP_Segment
class | TCP_Sender
class | TCP_Server_Application
class | TDL_Channel
| Tapped Delay Line (TDL) channel model. More...
class | Timer
| A virtual base class for timers. More...
class | Triangle_Source
| Triangle-wave source. More...
class | TTimer
class | Turbo_Codec
| Turbo encoder/decoder Class. More...
class | Uniform_RNG
| Uniform distribution. More...
class | Vec
| Vector Class (Templated) More...
class | Vector_Quantizer
| Class for vector quantization. More...
class | Weibull_RNG
| Weibull distribution. More...

## Typedefs

typedef Sparse_Vec< bin > | GF2vec_sparse
| Sparse GF(2) vector.
typedef Sparse_Mat< bin > | GF2mat_sparse
| Sparse GF(2) matrix.
typedef Normal_RNG | Gauss_RNG
| Gauss_RNG is the same as Normal Source.
typedef AR1_Normal_RNG | AR1_Gauss_RNG
| AR1_Gauss_RNG is the same as AR1_Normal_RNG.
typedef Vec< CFix > | cfixvec
| Typedef for complex fixed-point vector type.
typedef Mat< CFix > | cfixmat
| Typedef for complex fixed-point matrix type.
typedef CFixed< 1, TC, WRAP > | cfixed1
| Typedefs for CFixed (cfixed1, cfixed2, ..., cfixed64)
typedef Vec< Fix > | fixvec
| Typedef for fixed-point vector type.
typedef Mat< Fix > | fixmat
| Typedef for fixed-point matrix type.
typedef int64_t | fixrep
| Representation for fixed-point data types.
typedef Fixed< 1, TC, WRAP > | fixed1
| Typedefs for Fixed (fixed1, fixed2, ..., fixed64)
typedef Fixed< 1, US, WRAP > | ufixed1
| Typedefs for unsigned Fixed (ufixed1, ufixed2, ..., ufixed64)
typedef Fixed< 1, TC, SAT > | sfixed1
| Typedefs for saturated Fixed (sfixed1, sfixed2, ..., sfixed64)
typedef Fixed< 1, US, SAT > | sufixed1
| Typedefs for saturated unsigned Fixed (sufixed1, sufixed2, ..., sufixed64)
typedef double | Ttype
| 64-bit floating point time

## Enumerations

enum | error_msg_style { Full , Minimum }
| Style of assert, error and warning messages. More...
enum | SORTING_METHOD { INTROSORT = 0 , QUICKSORT = 1 , HEAPSORT = 2 , INSERTSORT = 3 }
| Sorting algorithms that can be used in a Sort class. More...
enum | CHANNEL_PROFILE { ITU_Vehicular_A , ITU_Vehicular_B , ITU_Pedestrian_A , ITU_Pedestrian_B , COST207_RA , COST207_RA6 , COST207_TU , COST207_TU6alt , COST207_TU12 , COST207_TU12alt , COST207_BU , COST207_BU6alt , COST207_BU12 , COST207_BU12alt , COST207_HT , COST207_HT6alt , COST207_HT12 , COST207_HT12alt , COST259_TUx , COST259_RAx , COST259_HTx }
| Predefined channel profiles. Includes LOS and Doppler spectrum settings. More...
enum | FADING_TYPE { Independent , Static , Correlated }
| Fading generator type: Independent (default), Static or Correlated. More...
enum | CORRELATED_METHOD { Rice_MEDS , IFFT , FIR }
| Correlated fading generation methods: Rice_MEDS (default), IFFT or FIR. More...
enum | RICE_METHOD { MEDS }
| Rice fading generation methods: MEDS. More...
enum | DOPPLER_SPECTRUM { Jakes = 0 , J = 0 , Classic = 0 , C = 0 , GaussI = 1 , Gauss1 = 1 , GI = 1 , G1 = 1 , GaussII = 2 , Gauss2 = 2 , GII = 2 , G2 = 2 }
| Predefined Doppler spectra. More...
enum | CONVOLUTIONAL_CODE_TYPE { MFD , ODS }
| Type of Convolutional Code. More...
enum | CONVOLUTIONAL_CODE_METHOD { Trunc , Tail , Tailbite }
| Encoding and decoding methods for Convolutional codes. More...
enum | Soft_Method { LOGMAP , APPROX }
| Soft demodulation methods. More...
enum | e_mode { TC , US }
| Sign encoding modes (aligned with SystemC) More...
enum | o_mode { SAT , SAT_ZERO , SAT_SYM , WRAP , WRAP_SM }
| Overflow modes (aligned with SystemC) More...
enum | q_mode { RND , RND_ZERO , RND_MIN_INF , RND_INF , RND_CONV , RND_CONV_ODD , TRN , TRN_ZERO }
| Quantization modes (aligned with SystemC) More...
enum | output_mode { OUTPUT_FIX , OUTPUT_FIX_SHIFT , OUTPUT_FLOAT , OUTPUT_FLOAT_SHIFT }
| Output modes. More...
enum | Newton_Search_Method { BFGS }
| Newton Search method. More...
enum | Line_Search_Method { Soft , Exact }
| Line Search method. More...
enum | Audio_Encoding { enc_unknown = 0 , enc_mulaw8 = 1 , enc_alaw8 = 27 , enc_linear8 = 2 , enc_linear16 = 3 , enc_linear24 = 4 , enc_linear32 = 5 , enc_float = 6 , enc_double = 7 }
| Supported encoding types for audio samples. More...

## Functions

bin | mxArray2bin (const mxArray *in)
| Convert the matlab-format mxArray to bin.
short | mxArray2short (const mxArray *in)
| Convert the matlab-format mxArray to short.
int | mxArray2int (const mxArray *in)
| Convert the matlab-format mxArray to int.
double | mxArray2double (const mxArray *in)
| Convert the matlab-format mxArray to double.
std::complex< double > | mxArray2double_complex (const mxArray *in)
| Convert the matlab-format mxArray to complex<double>
std::string | mxArray2string (const mxArray *in)
| Convert the matlab-format mxArray to string.
bvec | mxArray2bvec (const mxArray *in)
| Convert the matlab-format mxArray to bvec.
svec | mxArray2svec (const mxArray *in)
| Convert the matlab-format mxArray to svec.
ivec | mxArray2ivec (const mxArray *in)
| Convert the matlab-format mxArray to ivec.
vec | mxArray2vec (const mxArray *in)
| Convert the matlab-format mxArray to vec.
cvec | mxArray2cvec (const mxArray *in)
| Convert the matlab-format mxArray to cvec.
bmat | mxArray2bmat (const mxArray *in)
| Convert the matlab-format mxArray to bmat.
smat | mxArray2smat (const mxArray *in)
| Convert the matlab-format mxArray to smat.
imat | mxArray2imat (const mxArray *in)
| Convert the matlab-format mxArray to imat.
mat | mxArray2mat (const mxArray *in)
| Convert the matlab-format mxArray to mat.
cmat | mxArray2cmat (const mxArray *in)
| Convert the matlab-format mxArray to cmat.
void | bin2mxArray (const bin &in, mxArray *out)
| Convert bin to the matlab-format mxArray.
void | short2mxArray (const short &in, mxArray *out)
| Convert short to the matlab-format mxArray.
void | int2mxArray (const int &in, mxArray *out)
| Convert int to the matlab-format mxArray.
void | double2mxArray (const double &in, mxArray *out)
| Convert double to the matlab-format mxArray.
void | double_complex2mxArray (const std::complex< double > &in, mxArray *out)
| Convert complex<double> to the matlab-format mxArray.
void | string2mxArray (const std::string &in, mxArray *&out)
| Convert string to the matlab-format mxArray.
void | bvec2mxArray (const bvec &in, mxArray *out)
| Convert bvec to the matlab-format mxArray.
void | svec2mxArray (const svec &in, mxArray *out)
| Convert svec to the matlab-format mxArray.
void | ivec2mxArray (const ivec &in, mxArray *out)
| Convert ivec to the matlab-format mxArray.
void | vec2mxArray (const vec &in, mxArray *out)
| Convert vec to the matlab-format mxArray.
void | cvec2mxArray (const cvec &in, mxArray *out)
| Convert cvec to the matlab-format mxArray.
void | bmat2mxArray (const bmat &in, mxArray *out)
| Convert bmat to the matlab-format mxArray.
void | smat2mxArray (const smat &in, mxArray *out)
| Convert smat to the matlab-format mxArray.
void | imat2mxArray (const imat &in, mxArray *out)
| Convert imat to the matlab-format mxArray.
void | mat2mxArray (const mat &in, mxArray *out)
| Convert mat to the matlab-format mxArray.
void | cmat2mxArray (const cmat &in, mxArray *out)
| Convert cmat to the matlab-format mxArray.
void | mxArray2Csvec (const mxArray *in, short *out)
| Convert the matlab-format mxArray to C-format pointer to short.
void | mxArray2Civec (const mxArray *in, int *out)
| Convert the matlab-format mxArray to C-format pointer to int.
void | mxArray2Cvec (const mxArray *in, double *out)
| Convert the matlab-format mxArray to C-format pointer to double.
void | mxArray2Ccvec (const mxArray *in, double *out_real, double *out_imag)
| Convert the matlab-format mxArray to C-format pointers to double (real and imaginary parts)
void | mxArray2Csmat (const mxArray *in, short **out)
| Convert the matlab-format mxArray to C-format pointer to pointer to short.
void | mxArray2Cimat (const mxArray *in, int **out)
| Convert the matlab-format mxArray to C-format pointer to pointer to int.
void | mxArray2Cmat (const mxArray *in, double **out)
| Convert the matlab-format mxArray to C-format pointer to pointer to double.
void | mxArray2Ccmat (const mxArray *in, double **out_real, double **out_imag)
| Convert the matlab-format mxArray to C-format pointer to pointer to double (real and imaginary parts)
void | Csvec2mxArray (short *in, mxArray *out)
| Convert C-format pointer to short to matlab-format mxArray.
void | Civec2mxArray (int *in, mxArray *out)
| Convert C-format pointer to int to matlab-format mxArray.
void | Cvec2mxArray (double *in, mxArray *out)
| Convert C-format pointer to double to matlab-format mxArray.
void | Ccvec2mxArray (double *in_real, double *in_imag, mxArray *out)
| Convert C-format pointers to double (real and imaginary parts) to matlab-format mxArray.
void | Csmat2mxArray (short **in, mxArray *out)
| Convert C-format pointer to pointer to short to matlab-format mxArray.
void | Cimat2mxArray (int **in, mxArray *out)
| Convert C-format pointer to pointer to int to matlab-format mxArray.
void | Cmat2mxArray (double **in, mxArray *out)
| Convert C-format pointer to pointer to double to matlab-format mxArray.
void | Ccmat2mxArray (double **in_real, double **in_imag, mxArray *out)
| Convert C-format pointer to pointer to double (real and imaginary parts) to matlab-format mxArray.
template<class T >
const Array< T > | concat (const Array< T > &a, const T &e)
| Append element `e` to the end of the Array `a`.
template<class T >
const Array< T > | concat (const T &e, const Array< T > &a)
| Append element `e` to the beginning of the Array `a`.
template<class T >
const Array< T > | concat (const Array< T > &a1, const Array< T > &a2)
| Concat Arrays `a1` and `a2`.
template<class T >
const Array< T > | concat (const Array< T > &a1, const Array< T > &a2, const Array< T > &a3)
| Concat Arrays `a1`, `a2` and `a3`.
double | besselj (int nu, double x)
| Bessel function of first kind of order nu for nu integer.
vec | besselj (int nu, const vec &x)
| Bessel function of first kind of order nu for nu integer.
double | besselj (double nu, double x)
| Bessel function of first kind of order nu. nu is real.
vec | besselj (double nu, const vec &x)
| Bessel function of first kind of order nu. nu is real.
double | bessely (int nu, double x)
| Bessel function of second kind of order nu. nu is integer.
vec | bessely (int nu, const vec &x)
| Bessel function of second kind of order nu. nu is integer.
double | bessely (double nu, double x)
| Bessel function of second kind of order nu. nu is real.
vec | bessely (double nu, const vec &x)
| Bessel function of second kind of order nu. nu is real.
double | besseli (double nu, double x)
| Modified Bessel function of first kind of order nu. nu is double. x is double.
vec | besseli (double nu, const vec &x)
| Modified Bessel function of first kind of order nu. nu is double. x is double.
double | besselk (int nu, double x)
| Modified Bessel function of second kind of order nu. nu is double. x is double.
vec | besselk (int nu, const vec &x)
| Modified Bessel function of second kind of order nu. nu is double. x is double.
std::ostream & | operator<< (std::ostream &output, const bin &inbin)
| Output stream of bin.
std::istream & | operator>> (std::istream &input, bin &outbin)
| Input stream of bin.
bin | abs (const bin &inbin)
| absolute value of bin
template<typename T1 , typename T2 >
void | read_endian (T1 &st, T2 &data, bool switch_endian=false)
| Read binary data and optionally switch endianness.
template<typename T1 , typename T2 >
void | write_endian (T1 &st, T2 data, bool switch_endian=false)
| Write binary data and optionally switch endianness.
bool | exist (const std::string &name)
| Checks if a file named `name` already exists on the disk.
template<class T >
bvec | to_bvec (const Vec< T > &v)
| Converts a Vec<T> to bvec.
template<class T >
svec | to_svec (const Vec< T > &v)
| Converts a Vec<T> to svec.
template<class T >
ivec | to_ivec (const Vec< T > &v)
| Converts a Vec<T> to ivec.
template<class T >
vec | to_vec (const Vec< T > &v)
| Converts a Vec<T> to vec.
template<class T >
cvec | to_cvec (const Vec< T > &v)
| Converts a Vec<T> to cvec.
template<class T >
cvec | to_cvec (const Vec< T > &real, const Vec< T > &imag)
| Converts real and imaginary Vec<T> to cvec.
ivec | to_ivec (int s)
| Converts an int to ivec.
vec | to_vec (double s)
| Converts an double to vec.
cvec | to_cvec (double real, double imag)
| Converts real and imaginary double to cvec.
template<class T >
bmat | to_bmat (const Mat< T > &m)
| Converts a Mat<T> to bmat.
template<class T >
smat | to_smat (const Mat< T > &m)
| Converts a Mat<T> to smat.
template<class T >
imat | to_imat (const Mat< T > &m)
| Converts a Mat<T> to imat.
template<class T >
mat | to_mat (const Mat< T > &m)
| Converts a Mat<T> to mat.
template<class T >
cmat | to_cmat (const Mat< T > &m)
| Converts a Mat<T> to cmat.
template<class T >
cmat | to_cmat (const Mat< T > &real, const Mat< T > &imag)
| Converts real and imaginary Mat<T> to cmat.
ITPP_EXPORT bvec | dec2bin (int length, int index)
| Convert a decimal int index to bvec using length bits in the representation.
ITPP_EXPORT void | dec2bin (int index, bvec &v)
| Convert a decimal int index to bvec. Value returned in v.
ITPP_EXPORT bvec | dec2bin (int index, bool msb_first=true)
| Convert a decimal int index to bvec with the first bit as MSB if msb_first == true.
ITPP_EXPORT int | bin2dec (const bvec &inbvec, bool msb_first=true)
| Convert a bvec to decimal int with the first bit as MSB if msb_first == true.
ITPP_EXPORT bvec | oct2bin (const ivec &octalindex, short keepzeros=0)
| Convert ivec of octal form to bvec.
ITPP_EXPORT ivec | bin2oct (const bvec &inbits)
| Convert bvec to octal ivec.
ITPP_EXPORT ivec | bin2pol (const bvec &inbvec)
| Convert bvec to polar binary representation as ivec.
ITPP_EXPORT bvec | pol2bin (const ivec &inpol)
| Convert binary polar ivec to bvec.
double | rad_to_deg (double x)
| Convert radians to degrees.
double | deg_to_rad (double x)
| Convert degrees to radians.
ITPP_EXPORT double | round (double x)
| Round to nearest integer, return result in double.
ITPP_EXPORT vec | round (const vec &x)
| Round to nearest integer.
ITPP_EXPORT mat | round (const mat &x)
| Round to nearest integer.
ITPP_EXPORT int | round_i (double x)
| Round to nearest integer.
ITPP_EXPORT ivec | round_i (const vec &x)
| Round to nearest integer and return ivec.
ITPP_EXPORT imat | round_i (const mat &x)
| Round to nearest integer and return imat.
vec | ceil (const vec &x)
| Round to nearest upper integer.
mat | ceil (const mat &x)
| Round to nearest upper integer.
int | ceil_i (double x)
| The nearest larger integer.
ITPP_EXPORT ivec | ceil_i (const vec &x)
| Round to nearest upper integer.
ITPP_EXPORT imat | ceil_i (const mat &x)
| Round to nearest upper integer.
vec | floor (const vec &x)
| Round to nearest lower integer.
mat | floor (const mat &x)
| Round to nearest lower integer.
int | floor_i (double x)
| The nearest smaller integer.
ITPP_EXPORT ivec | floor_i (const vec &x)
| Round to nearest lower integer.
ITPP_EXPORT imat | floor_i (const mat &x)
| Round to nearest lower integer.
double | round_to_zero (double x, double threshold=1e-14)
| Round x to zero if abs(x) is smaller than threshold.
std::complex< double > | round_to_zero (const std::complex< double > &x, double threshold=1e-14)
| Round each part of x smaller than threshold to zero.
vec | round_to_zero (const vec &x, double threshold=1e-14)
| Round each element to zero if element < threshold.
mat | round_to_zero (const mat &x, double threshold=1e-14)
| Round each element to zero if element < threshold.
ITPP_EXPORT cvec | round_to_zero (const cvec &x, double threshold=1e-14)
| Round each element to zero if element < threshold.
ITPP_EXPORT cmat | round_to_zero (const cmat &x, double threshold=1e-14)
| Round each element to zero if element < threshold.
double | round_to_infty (const double in, const double threshold=1e9)
| Remove trailing digits, found after the decimal point, for numbers greater than threshold.
std::complex< double > | round_to_infty (const std::complex< double > &in, const double threshold=1e9)
| Remove trailing digits, found after the decimal point, for complex numbers whose real and imaginary parts are greater than threshold.
vec | round_to_infty (const vec &in, const double threshold=1e9)
| Remove trailing digits, found after the decimal point, for vectors greater than threshold.
mat | round_to_infty (const mat &in, const double threshold=1e9)
| Remove trailing digits, found after the decimal point, for matrices greater than threshold.
ITPP_EXPORT cvec | round_to_infty (const cvec &in, const double threshold=1e9)
| Remove trailing digits, found after the decimal point, for complex vectors greater than threshold.
ITPP_EXPORT cmat | round_to_infty (const cmat &in, const double threshold=1e9)
| Remove trailing digits, found after the decimal point, for complex matrices greater than threshold.
int | gray_code (int x)
| Convert to Gray Code.
template<typename T >
std::string | to_str (const T &i)
| Convert anything to string.
ITPP_EXPORT std::string | to_str (const double &i, const int precision)
| Convert double to string.
void | copy_vector (int n, const double *x, double *y)
void | copy_vector (int n, const std::complex< double > *x, std::complex< double > *y)
void | copy_vector (int n, const double *x, int incx, double *y, int incy)
void | copy_vector (int n, const std::complex< double > *x, int incx, std::complex< double > *y, int incy)
void | swap_vector (int n, double *x, double *y)
void | swap_vector (int n, std::complex< double > *x, std::complex< double > *y)
void | swap_vector (int n, double *x, int incx, double *y, int incy)
void | swap_vector (int n, std::complex< double > *x, int incx, std::complex< double > *y, int incy)
void | scal_vector (int n, double alpha, double *x)
void | scal_vector (int n, std::complex< double > alpha, std::complex< double > *x)
void | scal_vector (int n, double alpha, double *x, int incx)
void | scal_vector (int n, std::complex< double > alpha, std::complex< double > *x, int incx)
void | axpy_vector (int n, double alpha, const double *x, double *y)
void | axpy_vector (int n, std::complex< double > alpha, const std::complex< double > *x, std::complex< double > *y)
void | axpy_vector (int n, double alpha, const double *x, int incx, double *y, int incy)
void | axpy_vector (int n, std::complex< double > alpha, const std::complex< double > *x, int incx, std::complex< double > *y, int incy)
template<class T >
void | create_elements (T *&ptr, int n, const Factory &)
| Create an n-length array of T to be used as Array, Vec or Mat elements.
template<>
void | create_elements< unsigned char > (unsigned char *&ptr, int n, const Factory &)
| Specialization for unsigned char data arrays (used in GF2Mat)
template<>
void | create_elements< bin > (bin *&ptr, int n, const Factory &)
| Specialization for binary data arrays.
template<>
void | create_elements< short int > (short int *&ptr, int n, const Factory &)
| Specialization for short integer data arrays.
template<>
void | create_elements< int > (int *&ptr, int n, const Factory &)
| Specialization for integer data arrays.
template<>
void | create_elements< double > (double *&ptr, int n, const Factory &)
| Specialization for 16-byte aligned double data arrays.
template<>
void | create_elements< std::complex< double > > (std::complex< double > *&ptr, int n, const Factory &)
| Specialization for 16-byte aligned complex double data arrays.
template<class T >
void | destroy_elements (T *&ptr, int n)
| Destroy an array of Array, Vec or Mat elements.
template<>
void | destroy_elements< unsigned char > (unsigned char *&ptr, int)
| Specialization for unsigned char data arrays (used in GF2Mat)
template<>
void | destroy_elements< bin > (bin *&ptr, int)
| Specialization for binary data arrays.
template<>
void | destroy_elements< short int > (short int *&ptr, int)
| Specialization for short integer data arrays.
template<>
void | destroy_elements< int > (int *&ptr, int)
| Specialization for integer data arrays.
template<>
void | destroy_elements< double > (double *&ptr, int)
| Specialisation for 16-byte aligned double data arrays.
template<>
void | destroy_elements< std::complex< double > > (std::complex< double > *&ptr, int)
| Specialisation for 16-byte aligned complex double data arrays.
template<class T >
void | create_elements (Array< T > *&ptr, int n, const Factory &f)
| Create an n-length array of Array<T> to be used as Array elements.
template<class T >
void | create_elements (Mat< T > *&ptr, int n, const Factory &f)
| Create an n-length array of Mat<T> to be used as Array elements.
template<class T >
void | create_elements (Vec< T > *&ptr, int n, const Factory &f)
| Create an n-length array of Vec<T> to be used as Array elements.
void | sub_v_vT_m (mat &m, const vec &v)
| Calculates m=m-v*v'*m.
void | sub_m_v_vT (mat &m, const vec &v)
| Calculates m=m-m*v*v'.
GF2mat | gf2dense_eye (int m)
| GF(2) Identity matrix.
GF2mat | operator* (const GF2mat &X, const GF2mat &Y)
| GF(2) matrix multiplication.
bvec | operator* (const GF2mat &X, const bvec &y)
| GF(2) matrix multiplication with "regular" binary vector.
GF2mat | mult_trans (const GF2mat &X, const GF2mat &Y)
| Multiplication X*Y' where X and Y are GF(2) matrices.
GF2mat | operator+ (const GF2mat &X, const GF2mat &Y)
| GF(2) matrix addition.
std::ostream & | operator<< (std::ostream &os, const GF2mat &X)
| Output stream (plain text) operator for dense GF(2) matrices.
it_file & | operator<< (it_file &f, const GF2mat &X)
it_ifile & | operator>> (it_ifile &f, GF2mat &X)
template<typename T , typename Ftn >
Vec< T > | apply_functor (Ftn f, const Vec< T > &v)
| Help function to apply function object to Vec<T>
template<typename T >
Vec< T > | apply_function (T(*f)(T), const Vec< T > &v)
| Help function to call for a function: Vec<T> function(Vec<T>)
template<typename T >
Vec< T > | apply_function (T(*f)(const T &), const Vec< T > &v)
| Help function to call for a function: Vec<T> function(const Vec<T>&)
template<typename T , typename Ftn >
Mat< T > | apply_functor (Ftn f, const Mat< T > &m)
| Help function to apply function object to Mat<T>
template<typename T >
Mat< T > | apply_function (T(*f)(T), const Mat< T > &m)
| Help function to call for a function: Mat<T> function(Mat<T>&)
template<typename T >
Mat< T > | apply_function (T(*f)(const T &), const Mat< T > &m)
| Help function to call for a function: Mat<T> function(const Mat<T>&)
template<typename T >
Vec< T > | apply_function (T(*f)(T, T), const T &x, const Vec< T > &v)
| Help function to call for a function: Vec<T> function(T, Vec<T>)
template<typename T >
Vec< T > | apply_function (T(*f)(const T &, const T &), const T &x, const Vec< T > &v)
| Help function to call for a function: Vec<T> function(const T&, const Vec<T>&)
template<typename T >
Mat< T > | apply_function (T(*f)(T, T), const T &x, const Mat< T > &m)
| Help function to call for a function: Mat<T> function(T, Mat<T>)
template<typename T >
Mat< T > | apply_function (T(*f)(const T &, const T &), const T &x, const Mat< T > &m)
| Help function to call for a function: Mat<T> function(const T&, const Mat<T>&)
template<typename T >
Vec< T > | apply_function (T(*f)(T, T), const Vec< T > &v, const T &x)
| Help function to call for a function: Vec<T> function(Vec<T>, T)
template<typename T >
Vec< T > | apply_function (T(*f)(const T &, const T &), const Vec< T > &v, const T &x)
| Help function to call for a function: Vec<T> function(const Vec<T>&, const T&)
template<typename T >
Mat< T > | apply_function (T(*f)(T, T), const Mat< T > &m, const T &x)
| Help function to call for a function: Mat<T> function(Mat<T>, T)
template<typename T >
Mat< T > | apply_function (T(*f)(const T &, const T &), const Mat< T > &m, const T &x)
| Help function to call for a function: Mat<T> function(const Mat<T>&, const T&)
void | it_assert_f (std::string ass, std::string msg, std::string file, int line)
| Helper function for the `it_assert` and `it_assert_debug` macros.
void | it_error_f (std::string msg, std::string file, int line)
| Helper function for the `it_error` and `it_error_if` macros.
void | it_info_f (std::string msg)
| Helper function for the `it_info` and `it_info_debug` macros.
void | it_warning_f (std::string msg, std::string file, int line)
| Helper function for the `it_warning` macro.
void | it_enable_warnings ()
| Enable warnings.
void | it_disable_warnings ()
| Disable warnings.
void | it_redirect_warnings (std::ostream *warn_stream)
| Redirect warnings to the ostream warn_stream.
void | it_error_msg_style (error_msg_style style)
| Set preferred style of assert, error and warning messages.
ITPP_EXPORT void | it_enable_exceptions (bool on)
| Enable/disable using exceptions for error handling.
it_ifile & | operator>> (it_ifile &f, char &v)
| Read the char variable `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, bool &v)
| Read the bool variable `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, bin &v)
| Read the binary variable `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, short &v)
| Read the short variable `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, int &v)
| Read the integer variable `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, float &v)
| Read the float variable `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, double &v)
| Read the double variable `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, std::complex< float > &v)
| Read the float complex variable `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, std::complex< double > &v)
| Read the double complex variable `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, bvec &v)
| Read the bvec `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, svec &v)
| Read the svec `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, ivec &v)
| Read the ivec `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, vec &v)
| Read the vec `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, cvec &v)
| Read the cvec `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, std::string &str)
| Read the string `str` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, bmat &m)
| Read the bmat `m` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, smat &m)
| Read the smat `m` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, imat &m)
| Read the imat `m` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, mat &m)
| Read the mat `m` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, cmat &m)
| Read the cmat `m` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< bin > &v)
| Read the binary Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< short > &v)
| Read the short integer Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< int > &v)
| Read the integer Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< float > &v)
| Read the float Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< double > &v)
| Read the double Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< std::complex< float > > &v)
| Read the float complex Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< std::complex< double > > &v)
| Read the double complex Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< bvec > &v)
| Read the bvec Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< svec > &v)
| Read the svec Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< ivec > &v)
| Read the ivec Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< vec > &v)
| Read the vec Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< cvec > &v)
| Read the cvec Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< std::string > &v)
| Read the string Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< bmat > &v)
| Read the bmat Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< smat > &v)
| Read the bmat Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< imat > &v)
| Read the imat Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< mat > &v)
| Read the mat Array `v` from the `it_ifile` pointer.
it_ifile & | operator>> (it_ifile &f, Array< cmat > &v)
| Read the cmat Array `v` from the `it_ifile` pointer.
it_file & | operator<< (it_file &f, char x)
| Write the char variable `x` to the `it_file` pointer.
it_file & | operator<< (it_file &f, bool x)
| Write the bool variable `x` to the `it_file` pointer.
it_file & | operator<< (it_file &f, bin x)
| Write the binary variable `x` to the `it_file` pointer.
it_file & | operator<< (it_file &f, short x)
| Write the short variable `x` to the `it_file` pointer.
it_file & | operator<< (it_file &f, int x)
| Write the integer variable `x` to the `it_file` pointer.
it_file & | operator<< (it_file &f, float x)
| Write the float variable `x` to the `it_file` pointer.
it_file & | operator<< (it_file &f, double x)
| Write the double variable `x` to the `it_file` pointer.
it_file & | operator<< (it_file &f, std::complex< float > x)
| Write the float complex variable `x` to the `it_file` pointer.
it_file & | operator<< (it_file &f, std::complex< double > x)
| Write the double complex variable `x` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const bvec &v)
| Write the bvec `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const svec &v)
| Write the svec `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const ivec &v)
| Write the ivec `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const vec &v)
| Write the vec `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const cvec &v)
| Write the cvec `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const std::string &str)
| Write the string `str` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const bmat &m)
| Write the bmat `m` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const smat &m)
| Write the smat `m` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const imat &m)
| Write the imat `m` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const mat &m)
| Write the mat `m` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const cmat &m)
| Write the cmat `m` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< bin > &v)
| Write the bin Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< short > &v)
| Write the short int Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< int > &v)
| Write the int Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< float > &v)
| Write the float Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< double > &v)
| Write the double Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< std::complex< float > > &v)
| Write the float complex Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< std::complex< double > > &v)
| Write the double complex Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< bvec > &v)
| Write the bvec Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< svec > &v)
| Write the svec Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< ivec > &v)
| Write the ivec Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< vec > &v)
| Write the vec Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< cvec > &v)
| Write the cvec Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< std::string > &v)
| Write the string Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< bmat > &v)
| Write the bmat Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< smat > &v)
| Write the smat Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< imat > &v)
| Write the imat Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< mat > &v)
| Write the mat Array `v` to the `it_file` pointer.
it_file & | operator<< (it_file &f, const Array< cmat > &v)
| Write the cmat Array `v` to the `it_file` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, char &v)
| Read the char variable `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, bin &v)
| Read the binary variable `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, short &v)
| Read the short variable `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, int &v)
| Read the integer variable `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, double &v)
| Read the double variable `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, float &v)
| Read the float variable `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, std::complex< float > &v)
| Read the float complex variable `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, std::complex< double > &v)
| Read the double complex variable `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, vec &v)
| Read the vec `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, ivec &v)
| Read the ivec `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, bvec &v)
| Read the bvec `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, cvec &v)
| Read the cvec `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, std::string &str)
| Read the string `str` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, mat &m)
| Read the mat `m` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, imat &m)
| Read the imat `m` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, bmat &m)
| Read the bmat `m` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, cmat &m)
| Read the cmat `m` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< float > &v)
| Read the float Array `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< double > &v)
| Read the double Array `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< int > &v)
| Read the integer Array `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< bin > &v)
| Read the binary Array `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< std::complex< float > > &v)
| Read the float complex Array `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< std::complex< double > > &v)
| Read the double complex Array `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< vec > &v)
| Read the vec Array `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< ivec > &v)
| Read the ivec Array `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< bvec > &v)
| Read the bvec Array `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< cvec > &v)
| Read the cvec Array `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< std::string > &v)
| Read the string Array `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< mat > &v)
| Read the mat Array `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< imat > &v)
| Read the imat Array `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< bmat > &v)
| Read the bmat Array `v` from the `it_ifile_old` pointer.
it_ifile_old & | operator>> (it_ifile_old &f, Array< cmat > &v)
| Read the cmat Array `v` from the `it_ifile_old` pointer.
it_file_old & | operator<< (it_file_old &f, char x)
| Write the char variable `x` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, bin x)
| Write the binary variable `x` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, short x)
| Write the short variable `x` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, int x)
| Write the integer variable `x` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, float x)
| Write the float variable `x` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, double x)
| Write the double variable `x` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, std::complex< float > x)
| Write the float complex variable `x` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, std::complex< double > x)
| Write the double complex variable `x` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const vec &v)
| Write the vec `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const ivec &v)
| Write the ivec `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const bvec &v)
| Write the bvec `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const cvec &v)
| Write the cvec `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const std::string &str)
| Write the string `str` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const mat &m)
| Write the mat `m` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const imat &m)
| Write the imat `m` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const bmat &m)
| Write the bmat `m` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const cmat &m)
| Write the cmat `m` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< float > &v)
| Write the float Array `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< double > &v)
| Write the double Array `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< int > &v)
| Write the int Array `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< bin > &v)
| Write the bin Array `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< std::complex< float > > &v)
| Write the float complex Array `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< std::complex< double > > &v)
| Write the double complex Array `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< vec > &v)
| Write the vec Array `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< ivec > &v)
| Write the ivec Array `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< bvec > &v)
| Write the bvec Array `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< cvec > &v)
| Write the cvec Array `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< std::string > &v)
| Write the string Array `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< mat > &v)
| Write the mat Array `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< imat > &v)
| Write the imat Array `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< bmat > &v)
| Write the bmat Array `v` to the `it_file_old` pointer.
it_file_old & | operator<< (it_file_old &f, const Array< cmat > &v)
| Write the cmat Array `v` to the `it_file_old` pointer.
it_file & | flush (it_file &f)
| Flush operator.
it_ifile & | operator>> (it_ifile &f, const Name &s)
| Finds the variable `Name` in the `it_ifile`. Returns file pointer for reading.
it_file & | operator<< (it_file &f, const Name &s)
| Finds the variable `Name` in the `it_file`. Returns file pointer for writing.
template<class T >
void | it_save_var_as (const T &v, const std::string &name)
| Save the variable v in the file name.it as the name name.
template<class T >
void | it_load_var_as (T &v, const std::string &name)
| Load the variable v from the file name.it as the name name.
it_file_old & | flush (it_file_old &f)
| Flush operator.
it_ifile_old & | operator>> (it_ifile_old &f, const Name &s)
| Finds the variable `Name` in the `it_ifile_old`. Returns file pointer for reading.
it_file_old & | operator<< (it_file_old &f, const Name &s)
| Finds the variable `Name` in the `it_file_old`. Returns file pointer for writing.
template<class Num_T >
Mat< Num_T > | concat_horizontal (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Horizontal concatenation of two matrices.
template<class Num_T >
Mat< Num_T > | concat_vertical (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Vertical concatenation of two matrices.
template<class Num_T >
Mat< Num_T > | operator+ (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Addition of two matrices.
template<class Num_T >
Mat< Num_T > | operator+ (const Mat< Num_T > &m, Num_T t)
| Addition of a matrix and a scalar.
template<class Num_T >
Mat< Num_T > | operator+ (Num_T t, const Mat< Num_T > &m)
| Addition of a scalar and a matrix.
template<class Num_T >
Mat< Num_T > | operator- (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Subtraction of two matrices.
template<class Num_T >
Mat< Num_T > | operator- (const Mat< Num_T > &m, Num_T t)
| Subtraction of matrix and scalar.
template<class Num_T >
Mat< Num_T > | operator- (Num_T t, const Mat< Num_T > &m)
| Subtraction of scalar and matrix.
template<class Num_T >
Mat< Num_T > | operator- (const Mat< Num_T > &m)
| Negation of matrix.
template<class Num_T >
Mat< Num_T > | operator* (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Multiplication of two matrices.
template<class Num_T >
Vec< Num_T > | operator* (const Mat< Num_T > &m, const Vec< Num_T > &v)
| Multiplication of matrix and vector.
template<class Num_T >
Mat< Num_T > | operator* (const Mat< Num_T > &m, Num_T t)
| Multiplication of matrix and scalar.
template<class Num_T >
Mat< Num_T > | operator* (Num_T t, const Mat< Num_T > &m)
| Multiplication of scalar and matrix.
template<class Num_T >
Mat< Num_T > | elem_mult (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Element wise multiplication of two matrices.
template<class Num_T >
void | elem_mult_out (const Mat< Num_T > &m1, const Mat< Num_T > &m2, Mat< Num_T > &out)
| Element wise multiplication of two matrices, storing the result in matrix `out`.
template<class Num_T >
void | elem_mult_out (const Mat< Num_T > &m1, const Mat< Num_T > &m2, const Mat< Num_T > &m3, Mat< Num_T > &out)
| Element wise multiplication of three matrices, storing the result in matrix `out`.
template<class Num_T >
void | elem_mult_out (const Mat< Num_T > &m1, const Mat< Num_T > &m2, const Mat< Num_T > &m3, const Mat< Num_T > &m4, Mat< Num_T > &out)
| Element wise multiplication of four matrices, storing the result in matrix `out`.
template<class Num_T >
void | elem_mult_inplace (const Mat< Num_T > &m1, Mat< Num_T > &m2)
| In-place element wise multiplication of two matrices. Fast version of B = elem_mult(A, B).
template<class Num_T >
Num_T | elem_mult_sum (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Element wise multiplication of two matrices, followed by summation of the resultant elements. Fast version of sumsum(elem_mult(A, B)).
template<class Num_T >
Mat< Num_T > | operator/ (const Mat< Num_T > &m, Num_T t)
| Element-wise division by a scalar.
template<class Num_T >
Mat< Num_T > | operator/ (Num_T t, const Mat< Num_T > &m)
| Element-wise division (`t` is the dividend, elements of `m` are divisors)
template<class Num_T >
Mat< Num_T > | elem_div (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Element wise division of two matrices.
template<class Num_T >
void | elem_div_out (const Mat< Num_T > &m1, const Mat< Num_T > &m2, Mat< Num_T > &out)
| Element wise division of two matrices, storing the result in matrix `out`.
template<class Num_T >
Num_T | elem_div_sum (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Element wise division of two matrices, followed by summation of the resultant elements. Fast version of sumsum(elem_div(A, B)).
template<class T >
int | length (const Vec< T > &v)
| Length of vector.
template<class T >
int | size (const Vec< T > &v)
| Length of vector.
template<class T >
T | sum (const Vec< T > &v)
| Sum of all elements in the vector.
template<class T >
Vec< T > | sum (const Mat< T > &m, int dim=1)
| Sum of elements in the matrix `m`, either along columns or rows.
template<class T >
T | sumsum (const Mat< T > &X)
| Sum of all elements in the given matrix. Fast version of sum(sum(X))
template<class T >
T | sum_sqr (const Vec< T > &v)
| Sum of square of the elements in a vector.
template<class T >
Vec< T > | sum_sqr (const Mat< T > &m, int dim=1)
| Sum of the square of elements in the matrix `m`.
template<class T >
Vec< T > | cumsum (const Vec< T > &v)
| Cumulative sum of all elements in the vector.
template<class T >
Mat< T > | cumsum (const Mat< T > &m, int dim=1)
| Cumulative sum of elements in the matrix `m`.
template<class T >
T | prod (const Vec< T > &v)
| The product of all elements in the vector.
template<class T >
Vec< T > | prod (const Mat< T > &m, int dim=1)
| Product of elements in the matrix `m`.
template<class T >
Vec< T > | cross (const Vec< T > &v1, const Vec< T > &v2)
| Vector cross product. Vectors need to be of size 3.
template<class T >
Vec< T > | zero_pad (const Vec< T > &v, int n)
| Zero-pad a vector to size n.
template<class T >
Vec< T > | zero_pad (const Vec< T > &v)
| Zero-pad a vector to the nearest greater power of two.
template<class T >
Mat< T > | zero_pad (const Mat< T > &m, int rows, int cols)
| Zero-pad a matrix to size rows x cols.
template<class T >
T | index_zero_pad (const Vec< T > &v, const int index)
template<class T >
void | transpose (const Mat< T > &m, Mat< T > &out)
| Transposition of the matrix `m` returning the transposed matrix in `out`.
template<class T >
Mat< T > | transpose (const Mat< T > &m)
| Transposition of the matrix `m`.
template<class T >
void | hermitian_transpose (const Mat< T > &m, Mat< T > &out)
template<class T >
Mat< T > | hermitian_transpose (const Mat< T > &m)
| Hermitian transpose (complex conjugate transpose) of the matrix `m`.
template<class Num_T >
bool | is_hermitian (const Mat< Num_T > &X)
| Returns true if matrix `X` is hermitian, false otherwise.
template<class Num_T >
bool | is_unitary (const Mat< Num_T > &X)
| Returns true if matrix `X` is unitary, false otherwise.
template<class Num_T >
Mat< Num_T > | kron (const Mat< Num_T > &X, const Mat< Num_T > &Y)
| Computes the Kronecker product of two matrices.
ITPP_EXPORT cmat | sqrtm (const cmat &A)
| Square root of the complex square matrix `A`.
ITPP_EXPORT cmat | sqrtm (const mat &A)
| Square root of the real square matrix `A`.
template<class T >
int | rank (const Mat< T > &m, double tol=-1.0)
| Calculate the rank of matrix `m`.
template<>
int | rank (const imat &m, double tol)
| Specialisation of rank() function.
template<>
int | rank (const smat &m, double tol)
| Specialisation of rank() function.
template<>
int | rank (const bmat &, double)
| Specialisation of rank() function.
template<class T >
Mat< T > | diag (const Vec< T > &v, const int K=0)
| Create a diagonal matrix using vector `v` as its diagonal.
template<class T >
void | diag (const Vec< T > &v, Mat< T > &m)
| Create a diagonal matrix using vector `v` as its diagonal.
template<class T >
Vec< T > | diag (const Mat< T > &m)
| Get the diagonal elements of the input matrix `m`.
template<class T >
Mat< T > | bidiag (const Vec< T > &main, const Vec< T > &sup)
| Returns a matrix with the elements of the input vector `main` on the diagonal and the elements of the input vector `sup` on the diagonal row above.
template<class T >
void | bidiag (const Vec< T > &main, const Vec< T > &sup, Mat< T > &m)
| Returns in the output variable `m` a matrix with the elements of the input vector `main` on the diagonal and the elements of the input vector `sup` on the diagonal row above.
template<class T >
void | bidiag (const Mat< T > &m, Vec< T > &main, Vec< T > &sup)
| Returns the main diagonal and the diagonal row above in the two output vectors `main` and `sup`.
template<class T >
Mat< T > | tridiag (const Vec< T > &main, const Vec< T > &sup, const Vec< T > &sub)
| Returns a matrix with the elements of `main` on the diagonal, the elements of `sup` on the diagonal row above, and the elements of `sub` on the diagonal row below.
template<class T >
void | tridiag (const Vec< T > &main, const Vec< T > &sup, const Vec< T > &sub, Mat< T > &m)
| Returns in the output matrix `m` a matrix with the elements of `main` on the diagonal, the elements of `sup` on the diagonal row above, and the elements of `sub` on the diagonal row below.
template<class T >
void | tridiag (const Mat< T > &m, Vec< T > &main, Vec< T > &sup, Vec< T > &sub)
| Returns the main diagonal, the diagonal row above, and the diagonal row below int the output vectors `main`, `sup`, and `sub`.
template<class T >
T | trace (const Mat< T > &m)
| The trace of the matrix `m`, i.e. the sum of the diagonal elements.
template<class T >
Vec< T > | reverse (const Vec< T > &in)
| Reverse the input vector.
template<class T >
Vec< T > | rvectorize (const Mat< T > &m)
| Row vectorize the matrix [(0,0) (0,1) ... (N-1,N-2) (N-1,N-1)].
template<class T >
Vec< T > | cvectorize (const Mat< T > &m)
| Column vectorize the matrix [(0,0) (1,0) ... (N-2,N-1) (N-1,N-1)].
template<class T >
Mat< T > | reshape (const Mat< T > &m, int rows, int cols)
| Reshape the matrix into an rows*cols matrix.
template<class T >
Mat< T > | reshape (const Vec< T > &v, int rows, int cols)
| Reshape the vector into an rows*cols matrix.
ITPP_EXPORT bool | all (const bvec &testvec)
| Returns true if all elements are ones and false otherwise.
ITPP_EXPORT bool | any (const bvec &testvec)
| Returns true if any element is one and false otherwise.
vec | operator+ (const double &s, const ivec &v)
| Addition operator for double and ivec.
vec | operator- (const double &s, const ivec &v)
| Subtraction operator for double and ivec.
vec | operator* (const double &s, const ivec &v)
| Multiplication operator for double and ivec.
vec | operator/ (const double &s, const ivec &v)
| Division operator for double and ivec.
vec | operator/ (const ivec &v, const double &s)
| Division operator for ivec and double.
cvec | operator+ (const std::complex< double > &s, const ivec &v)
| Addition operator for complex<double> and ivec.
cvec | operator- (const std::complex< double > &s, const ivec &v)
| Subtraction operator for complex<double> and ivec.
cvec | operator* (const std::complex< double > &s, const ivec &v)
| Multiplication operator for complex<double> and ivec.
cvec | operator/ (const std::complex< double > &s, const ivec &v)
| Division operator for complex<double> and ivec.
cvec | operator/ (const ivec &v, const std::complex< double > &s)
| Division operator for ivec and complex<double>
cvec | operator+ (const double &s, const cvec &v)
| Addition operator for double and cvec.
cvec | operator- (const double &s, const cvec &v)
| Subtraction operator for double and cvec.
cvec | operator* (const double &s, const cvec &v)
| Multiplication operator for double and cvec.
cvec | operator/ (const cvec &v, const double &s)
| Division operator for cvec and double.
cvec | operator/ (const double &s, const cvec &v)
| Division operator for double and cvec.
cmat | operator+ (const double &s, const cmat &m)
| Addition operator for double and cmat.
cmat | operator- (const double &s, const cmat &m)
| Subtraction operator for double and cmat.
cmat | operator* (const double &s, const cmat &m)
| Multiplication operator for double and cmat.
cmat | operator* (const std::complex< double > &s, const mat &m)
| Multiplication operator for complex<double> and mat.
cmat | operator/ (const cmat &m, const double &s)
| Division operator for cmat and double.
cvec | operator* (const std::complex< double > &s, const vec &v)
| Multiplication operator for complex<double> and vec.
cvec | operator* (const vec &v, const std::complex< double > &s)
| Multiplication operator for vec and complex<double>
vec | operator+ (const bvec &a, const vec &b)
| Addition operator for bvec and vec.
vec | operator+ (const svec &a, const vec &b)
| Addition operator for svec and vec.
vec | operator+ (const ivec &a, const vec &b)
| Addition operator for ivec and vec.
cvec | operator+ (const bvec &a, const cvec &b)
| Addition operator for bvec and cvec.
cvec | operator+ (const svec &a, const cvec &b)
| Addition operator for svec and cvec.
cvec | operator+ (const ivec &a, const cvec &b)
| Addition operator for ivec and cvec.
double | operator* (const bvec &a, const vec &b)
| Multiplication operator for bvec and vec.
double | operator* (const svec &a, const vec &b)
| Multiplication operator for svec and vec.
double | operator* (const ivec &a, const vec &b)
| Multiplication operator for ivec and vec.
std::complex< double > | operator* (const bvec &a, const cvec &b)
| Multiplication operator for bvec and cvec.
std::complex< double > | operator* (const svec &a, const cvec &b)
| Multiplication operator for svec and cvec.
std::complex< double > | operator* (const ivec &a, const cvec &b)
| Multiplication operator for ivec and cvec.
mat | operator+ (const bmat &a, const mat &b)
| Addition operator for bmat and mat.
mat | operator+ (const smat &a, const mat &b)
| Addition operator for smat and mat.
mat | operator+ (const imat &a, const mat &b)
| Addition operator for imat and mat.
cmat | operator+ (const bmat &a, const cmat &b)
| Addition operator for bmat and cmat.
cmat | operator+ (const smat &a, const cmat &b)
| Addition operator for smat and cmat.
cmat | operator+ (const imat &a, const cmat &b)
| Addition operator for imat and cmat.
cmat | operator+ (const mat &a, const cmat &b)
| Addition operator for mat and cmat.
std::complex< double > | operator+ (const int &x, const std::complex< double > &y)
| Addition operator for int and complex double.
std::complex< double > | operator+ (const float &x, const std::complex< double > &y)
| Addition operator for float and complex double.
std::complex< double > | operator+ (const std::complex< double > &x, const int &y)
| Addition operator for int and complex double.
std::complex< double > | operator+ (const std::complex< double > &x, const float &y)
| Addition operator for float and complex double.
std::complex< double > | operator- (const int &x, const std::complex< double > &y)
| Subtraction operator for int and complex double.
std::complex< double > | operator- (const float &x, const std::complex< double > &y)
| Subtraction operator for float and complex double.
std::complex< double > | operator- (const std::complex< double > &x, const int &y)
| Subtraction operator for int and complex double.
std::complex< double > | operator- (const std::complex< double > &x, const float &y)
| Subtraction operator for float and complex double.
std::complex< double > | operator* (const int &x, const std::complex< double > &y)
| Multiplication operator for int and complex double.
std::complex< double > | operator* (const float &x, const std::complex< double > &y)
| Multiplication operator for float and complex double.
std::complex< double > | operator* (const std::complex< double > &x, const int &y)
| Multiplication operator for int and complex double.
std::complex< double > | operator* (const std::complex< double > &x, const float &y)
| Multiplication operator for float and complex double.
std::complex< double > | operator/ (const std::complex< double > &x, const int &y)
| Division operator for complex double and int.
std::complex< double > | operator/ (const std::complex< double > &x, const float &y)
| Division operator for complex double and float.
vec | operator+ (const float &s, const vec &v)
| Addition operator for float and vec.
vec | operator+ (const short &s, const vec &v)
| Addition operator for short and vec.
vec | operator+ (const int &s, const vec &v)
| Addition operator for int and vec.
vec | operator+ (const vec &v, const float &s)
| Addition operator for vec and float.
vec | operator+ (const vec &v, const short &s)
| Addition operator for vec and short.
vec | operator+ (const vec &v, const int &s)
| Addition operator for vec and int.
vec | operator- (const float &s, const vec &v)
| Subtraction operator for float and vec.
vec | operator- (const short &s, const vec &v)
| Subtraction operator for short and vec.
vec | operator- (const int &s, const vec &v)
| Subtraction operator for int and vec.
vec | operator- (const vec &v, const float &s)
| Subtraction operator for vec and float.
vec | operator- (const vec &v, const short &s)
| Subtraction operator for vec and short.
vec | operator- (const vec &v, const int &s)
| Subtraction operator for vec and int.
vec | operator* (const float &s, const vec &v)
| Multiplication operator for float and vec.
vec | operator* (const short &s, const vec &v)
| Multiplication operator for short and vec.
vec | operator* (const int &s, const vec &v)
| Multiplication operator for int and vec.
vec | operator* (const vec &v, const float &s)
| Multiplication operator for vec and float.
vec | operator* (const vec &v, const short &s)
| Multiplication operator for vec and short.
vec | operator* (const vec &v, const int &s)
| Multiplication operator for vec and int.
vec | operator/ (const vec &v, const float &s)
| Division operator for vec and float.
vec | operator/ (const vec &v, const short &s)
| Division operator for vec and short.
vec | operator/ (const vec &v, const int &s)
| Division operator for vec and int.
vec | operator+ (const ivec &v, const double &s)
| Addition operator for ivec and double.
vec | operator- (const ivec &v, const double &s)
| Subtraction operator for ivec and double.
vec | operator* (const ivec &v, const double &s)
| Multiplication operator for ivec and double.
cvec | operator+ (const ivec &v, const std::complex< double > &s)
| Addition operator for ivec and complex<double>
cvec | operator- (const ivec &v, const std::complex< double > &s)
| Subtraction operator for ivec and complex<double>
cvec | operator* (const ivec &v, const std::complex< double > &s)
| Multiplication operator for ivec and complex<double>
cvec | operator+ (const float &s, const cvec &v)
| Addition operator for float and cvec.
cvec | operator+ (const short &s, const cvec &v)
| Addition operator for short and cvec.
cvec | operator+ (const int &s, const cvec &v)
| Addition operator for int and cvec.
cvec | operator+ (const cvec &v, const float &s)
| Addition operator for cvec and float.
cvec | operator+ (const cvec &v, const double &s)
| Addition operator for cvec and double.
cvec | operator+ (const cvec &v, const short &s)
| Addition operator for cvec and short.
cvec | operator+ (const cvec &v, const int &s)
| Addition operator for cvec and int.
cvec | operator- (const float &s, const cvec &v)
| Subtraction operator for float and cvec.
cvec | operator- (const short &s, const cvec &v)
| Subtraction operator for short and cvec.
cvec | operator- (const int &s, const cvec &v)
| Subtraction operator for int and cvec.
cvec | operator- (const cvec &v, const float &s)
| Subtraction operator for cvec and float.
cvec | operator- (const cvec &v, const double &s)
| Subtraction operator for cvec and double.
cvec | operator- (const cvec &v, const short &s)
| Subtraction operator for cvec and short.
cvec | operator- (const cvec &v, const int &s)
| Subtraction operator for cvec and int.
cvec | operator* (const float &s, const cvec &v)
| Multiplication operator for float and cvec.
cvec | operator* (const short &s, const cvec &v)
| Multiplication operator for short and cvec.
cvec | operator* (const int &s, const cvec &v)
| Multiplication operator for int and cvec.
cvec | operator* (const cvec &v, const float &s)
| Multiplication operator for cvec and float.
cvec | operator* (const cvec &v, const double &s)
| Multiplication operator for cvec and double.
cvec | operator* (const cvec &v, const short &s)
| Multiplication operator for cvec and short.
cvec | operator* (const cvec &v, const int &s)
| Multiplication operator for cvec and int.
cvec | operator/ (const cvec &v, const float &s)
| Division operator for cvec and float.
cvec | operator/ (const cvec &v, const short &s)
| Division operator for cvec and short.
cvec | operator/ (const cvec &v, const int &s)
| Division operator for cvec and int.
mat | operator+ (const float &s, const mat &m)
| Addition operator for float and mat.
mat | operator+ (const short &s, const mat &m)
| Addition operator for short and mat.
mat | operator+ (const int &s, const mat &m)
| Addition operator for int and mat.
mat | operator+ (const mat &m, const float &s)
| Addition operator for mat and float.
mat | operator+ (const mat &m, const short &s)
| Addition operator for mat and short.
mat | operator+ (const mat &m, const int &s)
| Addition operator for mat and int.
mat | operator- (const float &s, const mat &m)
| Subtraction operator for float and mat.
mat | operator- (const short &s, const mat &m)
| Subtraction operator for short and mat.
mat | operator- (const int &s, const mat &m)
| Subtraction operator for int and mat.
mat | operator- (const mat &m, const float &s)
| Subtraction operator for mat and float.
mat | operator- (const mat &m, const short &s)
| Subtraction operator for mat and short.
mat | operator- (const mat &m, const int &s)
| Subtraction operator for mat and int.
mat | operator* (const float &s, const mat &m)
| Multiplication operator for float and mat.
mat | operator* (const short &s, const mat &m)
| Multiplication operator for short and mat.
mat | operator* (const int &s, const mat &m)
| Multiplication operator for int and mat.
mat | operator* (const mat &m, const float &s)
| Multiplication operator for mat and float.
mat | operator* (const mat &m, const short &s)
| Multiplication operator for mat and short.
mat | operator* (const mat &m, const int &s)
| Multiplication operator for mat and int.
mat | operator/ (const mat &m, const float &s)
| Division operator for mat and float.
mat | operator/ (const mat &m, const short &s)
| Division operator for mat and short.
mat | operator/ (const mat &m, const int &s)
| Division operator for mat and int.
cmat | operator* (const mat &m, const std::complex< double > &s)
| Multiplication operator for mat and complex<double>
vec | operator+ (const vec &a, const bvec &b)
| Addition operator for vec and bvec.
vec | operator+ (const vec &a, const svec &b)
| Addition operator for vec and svec.
vec | operator+ (const vec &a, const ivec &b)
| Addition operator for vec and ivec.
vec | operator- (const bvec &a, const vec &b)
| Subtraction operator for bvec and vec.
vec | operator- (const svec &a, const vec &b)
| Subtraction operator for svec and vec.
vec | operator- (const ivec &a, const vec &b)
| Subtraction operator for ivec and vec.
vec | operator- (const vec &a, const bvec &b)
| Subtraction operator for vec and bvec.
vec | operator- (const vec &a, const svec &b)
| Subtraction operator for vec and svec.
vec | operator- (const vec &a, const ivec &b)
| Subtraction operator for vec and ivec.
double | operator* (const vec &a, const bvec &b)
| Multiplication operator for vec and bvec.
double | operator* (const vec &a, const svec &b)
| Multiplication operator for vec and svec.
double | operator* (const vec &a, const ivec &b)
| Multiplication operator for vec and ivec.
cvec | operator+ (const cvec &a, const bvec &b)
| Addition operator for cvec and bvec.
cvec | operator+ (const cvec &a, const svec &b)
| Addition operator for cvec and svec.
cvec | operator+ (const cvec &a, const ivec &b)
| Addition operator for cvec and ivec.
cvec | operator- (const bvec &a, const cvec &b)
| Subtraction operator for bvec and cvec.
cvec | operator- (const svec &a, const cvec &b)
| Subtraction operator for svec and cvec.
cvec | operator- (const ivec &a, const cvec &b)
| Subtraction operator for ivec and cvec.
cvec | operator- (const cvec &a, const bvec &b)
| Subtraction operator for cvec and bvec.
cvec | operator- (const cvec &a, const svec &b)
| Subtraction operator for cvec and svec.
cvec | operator- (const cvec &a, const ivec &b)
| Subtraction operator for cvec and ivec.
std::complex< double > | operator* (const cvec &a, const bvec &b)
| Multiplication operator for cvec and bvec.
std::complex< double > | operator* (const cvec &a, const svec &b)
| Multiplication operator for cvec and svec.
std::complex< double > | operator* (const cvec &a, const ivec &b)
| Multiplication operator for cvec and ivec.
mat | operator+ (const mat &a, const bmat &b)
| Addition operator for mat and bmat.
mat | operator+ (const mat &a, const smat &b)
| Addition operator for mat and smat.
mat | operator+ (const mat &a, const imat &b)
| Addition operator for mat and imat.
mat | operator- (const bmat &a, const mat &b)
| Subtraction operator for bmat and mat.
mat | operator- (const smat &a, const mat &b)
| Subtraction operator for smat and mat.
mat | operator- (const imat &a, const mat &b)
| Subtraction operator for imat and mat.
mat | operator- (const mat &a, const bmat &b)
| Subtraction operator for mat and bmat.
mat | operator- (const mat &a, const smat &b)
| Subtraction operator for mat and smat.
mat | operator- (const mat &a, const imat &b)
| Subtraction operator for mat and imat.
cmat | operator+ (const cmat &a, const bmat &b)
| Addition operator for cmat and bmat.
cmat | operator+ (const cmat &a, const smat &b)
| Addition operator for cmat and smat.
cmat | operator+ (const cmat &a, const imat &b)
| Addition operator for cmat and imat.
cmat | operator+ (const cmat &a, const mat &b)
| Addition operator for cmat and mat.
cmat | operator- (const bmat &a, const cmat &b)
| Subtraction operator for bmat and cmat.
cmat | operator- (const smat &a, const cmat &b)
| Subtraction operator for smat and cmat.
cmat | operator- (const imat &a, const cmat &b)
| Subtraction operator for imat and cmat.
cmat | operator- (const mat &a, const cmat &b)
| Subtraction operator for mat and cmat.
cmat | operator- (const cmat &a, const bmat &b)
| Subtraction operator for cmat and bmat.
cmat | operator- (const cmat &a, const smat &b)
| Subtraction operator for cmat and smat.
cmat | operator- (const cmat &a, const imat &b)
| Subtraction operator for cmat and imat.
cmat | operator- (const cmat &a, const mat &b)
| Subtraction operator for cmat and mat.
cmat | operator* (const mat &a, const cmat &b)
| Multiplication operator for mat and cmat.
cmat | operator* (const bmat &a, const cmat &b)
| Multiplication operator for bmat and cmat.
cmat | operator* (const smat &a, const cmat &b)
| Multiplication operator for smat and cmat.
cmat | operator* (const imat &a, const cmat &b)
| Multiplication operator for imat and cmat.
cmat | operator* (const cmat &a, const mat &b)
| Multiplication operator for cmat and mat.
cmat | operator* (const cmat &a, const bmat &b)
| Multiplication operator for cmat and bmat.
cmat | operator* (const cmat &a, const smat &b)
| Multiplication operator for cmat and smat.
cmat | operator* (const cmat &a, const imat &b)
| Multiplication operator for cmat and imat.
GlobalSeedProvider & | global_seed_provider ()
void | GlobalRNG_reset (unsigned int seed)
| Set the internal seed of the Global Seed Provider.
void | GlobalRNG_reset ()
| Reset the internal seed of the Global Seed Provider to the previously set value.
unsigned int | GlobalRNG_get_local_seed ()
| Get new seed to initialize thread-local generators.
void | GlobalRNG_randomize ()
| Set a random seed for the Global Seed Provider seed.
void | GlobalRNG_get_state (ivec &state)
| Save current full state of global seed provider in memory.
void | GlobalRNG_set_state (const ivec &state)
| Resume the global seed provider state saved in memory.
void | RNG_reset (unsigned int seed)
| Set the seed for all Random Number Generators in the current thread.
void | RNG_reset ()
| Reset the seed to the previously set value for all Random Number Generators in the current thread.
void | RNG_randomize ()
| Set a random seed for all Random Number Generators in the current thread.
void | RNG_get_state (ivec &state)
| Save Random Number generation context used in the current thread.
void | RNG_set_state (const ivec &state)
| Resume Random Number generation in the current thread with previously stored context.
bin | randb (void)
| Generates a random bit (equally likely 0s and 1s)
void | randb (int size, bvec &out)
| Generates a random bit vector (equally likely 0s and 1s)
bvec | randb (int size)
| Generates a random bit vector (equally likely 0s and 1s)
void | randb (int rows, int cols, bmat &out)
| Generates a random bit matrix (equally likely 0s and 1s)
bmat | randb (int rows, int cols)
| Generates a random bit matrix (equally likely 0s and 1s)
double | randu (void)
| Generates a random uniform (0,1) number.
void | randu (int size, vec &out)
| Generates a random uniform (0,1) vector.
vec | randu (int size)
| Generates a random uniform (0,1) vector.
void | randu (int rows, int cols, mat &out)
| Generates a random uniform (0,1) matrix.
mat | randu (int rows, int cols)
| Generates a random uniform (0,1) matrix.
int | randi (int low, int high)
| Generates a random integer in the interval [low,high].
ivec | randi (int size, int low, int high)
| Generates a random ivec with elements in the interval [low,high].
imat | randi (int rows, int cols, int low, int high)
| Generates a random imat with elements in the interval [low,high].
vec | randray (int size, double sigma=1.0)
| Generates a random Rayleigh vector.
vec | randrice (int size, double sigma=1.0, double s=1.0)
| Generates a random Rice vector (See J.G. Poakis, "Digital Communications, 3rd ed." p.47)
vec | randexp (int size, double lambda=1.0)
| Generates a random complex Gaussian vector.
double | randn (void)
| Generates a random Gaussian (0,1) variable.
void | randn (int size, vec &out)
| Generates a random Gaussian (0,1) vector.
vec | randn (int size)
| Generates a random Gaussian (0,1) vector.
void | randn (int rows, int cols, mat &out)
| Generates a random Gaussian (0,1) matrix.
mat | randn (int rows, int cols)
| Generates a random Gaussian (0,1) matrix.
std::complex< double > | randn_c (void)
| Generates a random complex Gaussian (0,1) variable.
void | randn_c (int size, cvec &out)
| Generates a random complex Gaussian (0,1) vector.
cvec | randn_c (int size)
| Generates a random complex Gaussian (0,1) vector.
void | randn_c (int rows, int cols, cmat &out)
| Generates a random complex Gaussian (0,1) matrix.
cmat | randn_c (int rows, int cols)
| Generates a random complex Gaussian (0,1) matrix.
template<class T >
Sparse_Mat< T > | operator+ (const Sparse_Mat< T > &m1, const Sparse_Mat< T > &m2)
| m1+m2 where m1 and m2 are sparse matrices
template<class T >
Sparse_Mat< T > | operator* (const T &c, const Sparse_Mat< T > &m)
| c*m where c is a scalar and m is a sparse matrix
template<class T >
Sparse_Mat< T > | operator* (const Sparse_Mat< T > &m1, const Sparse_Mat< T > &m2)
| m1*m2 where m1 and m2 are sparse matrices
template<class T >
Sparse_Vec< T > | operator* (const Sparse_Mat< T > &m, const Sparse_Vec< T > &v)
| m*v where m is a sparse matrix and v is a sparse vector
template<class T >
Vec< T > | operator* (const Sparse_Mat< T > &m, const Vec< T > &v)
| m*v where m is a sparse matrix and v is a full column vector
template<class T >
Vec< T > | operator* (const Vec< T > &v, const Sparse_Mat< T > &m)
| v'*m where m is a sparse matrix and v is a full column vector
template<class T >
Mat< T > | trans_mult (const Sparse_Mat< T > &m)
| m'*m where m is a sparse matrix
template<class T >
Sparse_Mat< T > | trans_mult_s (const Sparse_Mat< T > &m)
| m'*m where m is a sparse matrix
template<class T >
Sparse_Mat< T > | trans_mult (const Sparse_Mat< T > &m1, const Sparse_Mat< T > &m2)
| m1'*m2 where m1 and m2 are sparse matrices
template<class T >
Vec< T > | trans_mult (const Sparse_Mat< T > &m, const Vec< T > &v)
| m'*v where m is a sparse matrix and v is a full column vector
template<class T >
Sparse_Mat< T > | mult_trans (const Sparse_Mat< T > &m1, const Sparse_Mat< T > &m2)
| m1*m2' where m1 and m2 are sparse matrices
template<class T >
Sparse_Mat< T > | sparse (const Mat< T > &m, T epsilon)
| Convert a dense matrix `m` into its sparse representation.
template<class T >
Mat< T > | full (const Sparse_Mat< T > &s)
| Convert a sparse matrix `s` into its dense representation.
template<class T >
Sparse_Mat< T > | transpose (const Sparse_Mat< T > &s)
| Transpose a sparse matrix `s`.
ivec | find (const bvec &invector)
| Return a integer vector with indicies where bvec == 1.
vec | impulse (int size)
| Impulse vector.
vec | linspace (double from, double to, int length=100)
| linspace (works in the same way as the MATLAB version)
vec | zigzag_space (double t0, double t1, int K=5)
| Zig-zag space function (variation on linspace)
imat | hadamard (int size)
| Hadamard matrix.
imat | jacobsthal (int p)
| Jacobsthal matrix.
imat | conference (int n)
| Conference matrix.
const cmat | toeplitz (const cvec &c)
| Generate symmetric Toeplitz matrix from vector `c` (complex valued)
mat | rotation_matrix (int dim, int plane1, int plane2, double angle)
| Create a rotation matrix that rotates the given plane `angle` radians. Note that the order of the planes are important!
void | house (const vec &x, vec &v, double &beta)
| Calcualte the Householder vector.
void | givens (double a, double b, double &c, double &s)
| Calculate the Givens rotation values.
void | givens (double a, double b, mat &m)
| Calculate the Givens rotation matrix.
mat | givens (double a, double b)
| Calculate the Givens rotation matrix.
void | givens_t (double a, double b, mat &m)
| Calculate the transposed Givens rotation matrix.
mat | givens_t (double a, double b)
| Calculate the transposed Givens rotation matrix.
template void | eye (int, mat &)
| Template instantiation of eye.
template void | eye (int, bmat &)
| Template instantiation of eye.
template void | eye (int, imat &)
| Template instantiation of eye.
template void | eye (int, cmat &)
| Template instantiation of eye.
template vec | linspace_fixed_step (double, double, double)
| Template instantiation of linspace_fixed_step.
template ivec | linspace_fixed_step (int, int, int)
| Template instantiation of linspace_fixed_step.
template svec | linspace_fixed_step (short int, short int, short int)
| Template instantiation of linspace_fixed_step.
ITPP_EXPORT vec | ones (int size)
| A float vector of ones.
ITPP_EXPORT bvec | ones_b (int size)
| A Binary vector of ones.
ITPP_EXPORT ivec | ones_i (int size)
| A Int vector of ones.
ITPP_EXPORT cvec | ones_c (int size)
| A float Complex vector of ones.
ITPP_EXPORT mat | ones (int rows, int cols)
| A float (rows,cols)-matrix of ones.
ITPP_EXPORT bmat | ones_b (int rows, int cols)
| A Binary (rows,cols)-matrix of ones.
ITPP_EXPORT imat | ones_i (int rows, int cols)
| A Int (rows,cols)-matrix of ones.
ITPP_EXPORT cmat | ones_c (int rows, int cols)
| A Double Complex (rows,cols)-matrix of ones.
ITPP_EXPORT vec | zeros (int size)
| A Double vector of zeros.
ITPP_EXPORT bvec | zeros_b (int size)
| A Binary vector of zeros.
ITPP_EXPORT ivec | zeros_i (int size)
| A Int vector of zeros.
ITPP_EXPORT cvec | zeros_c (int size)
| A Double Complex vector of zeros.
ITPP_EXPORT mat | zeros (int rows, int cols)
| A Double (rows,cols)-matrix of zeros.
ITPP_EXPORT bmat | zeros_b (int rows, int cols)
| A Binary (rows,cols)-matrix of zeros.
ITPP_EXPORT imat | zeros_i (int rows, int cols)
| A Int (rows,cols)-matrix of zeros.
ITPP_EXPORT cmat | zeros_c (int rows, int cols)
| A Double Complex (rows,cols)-matrix of zeros.
ITPP_EXPORT mat | eye (int size)
| A Double (size,size) unit matrix.
ITPP_EXPORT bmat | eye_b (int size)
| A Binary (size,size) unit matrix.
ITPP_EXPORT imat | eye_i (int size)
| A Int (size,size) unit matrix.
ITPP_EXPORT cmat | eye_c (int size)
| A Double Complex (size,size) unit matrix.
template<class T >
void | eye (int size, Mat< T > &m)
| A non-copying version of the eye function.
template<class T >
Vec< T > | linspace_fixed_step (T from, T to, T step=1)
| linspace_fixed_step (works in the same way as "from:step:to" in MATLAB)
template<typename Num_T >
const Mat< Num_T > | toeplitz (const Vec< Num_T > &c, const Vec< Num_T > &r)
| Generate Toeplitz matrix from two vectors `c` and `r`.
template<typename Num_T >
const Mat< Num_T > | toeplitz (const Vec< Num_T > &c)
| Generate symmetric Toeplitz matrix from vector `c`.
template<class T >
Sparse_Vec< T > | operator+ (const Sparse_Vec< T > &v1, const Sparse_Vec< T > &v2)
| v1+v2 where v1 and v2 are sparse vector
template<class T >
T | operator* (const Sparse_Vec< T > &v1, const Sparse_Vec< T > &v2)
| v1*v2 where v1 and v2 are sparse vectors
template<class T >
T | operator* (const Sparse_Vec< T > &v1, const Vec< T > &v2)
| v1*v2 where v1 is a sparse vector and v2 is a dense vector
template<class T >
T | operator* (const Vec< T > &v1, const Sparse_Vec< T > &v2)
| v1*v2 where v1 is a dense vector and v2 is a sparse vector
template<class T >
Sparse_Vec< T > | elem_mult (const Sparse_Vec< T > &v1, const Sparse_Vec< T > &v2)
| Elementwise multiplication of two sparse vectors returning a sparse vector.
template<class T >
Vec< T > | elem_mult (const Sparse_Vec< T > &v1, const Vec< T > &v2)
| Elementwise multiplication of a sparse vector and a dense vector returning a dense vector.
template<class T >
Sparse_Vec< T > | elem_mult_s (const Sparse_Vec< T > &v1, const Vec< T > &v2)
| Elementwise multiplication of a sparse vector and a dense vector returning a sparse vector.
template<class T >
Vec< T > | elem_mult (const Vec< T > &v1, const Sparse_Vec< T > &v2)
| Elementwise multiplication of a dense vector and a sparse vector returning a dense vector.
template<class T >
Sparse_Vec< T > | elem_mult_s (const Vec< T > &v1, const Sparse_Vec< T > &v2)
| Elementwise multiplication of a dense vector and a sparse vector returning a sparse vector.
template<class T >
Sparse_Vec< T > | sparse (const Vec< T > &v)
| Convert a dense vector `v` into its sparse representation.
template<class T >
Sparse_Vec< T > | sparse (const Vec< T > &v, T epsilon)
| Convert a dense vector `v` into its sparse representation.
template<class T >
Vec< T > | full (const Sparse_Vec< T > &s)
| Convert a sparse vector `s` into its dense representation.
void | tic ()
| Reset and start timer.
double | toc ()
| Returns the elapsed time since last tic()
void | toc_print ()
| Prints the elapsed time since last tic()
void | pause (double t=-1)
| pause
template<class Num_T >
Vec< Num_T > | operator+ (const Vec< Num_T > &v1, const Vec< Num_T > &v2)
| Addition of two vectors.
template<class Num_T >
Vec< Num_T > | operator+ (const Vec< Num_T > &v, Num_T t)
| Addition of a vector and a scalar.
template<class Num_T >
Vec< Num_T > | operator+ (Num_T t, const Vec< Num_T > &v)
| Addition of a scalar and a vector.
template<class Num_T >
Vec< Num_T > | operator- (const Vec< Num_T > &v1, const Vec< Num_T > &v2)
| Subtraction of a vector from a vector.
template<class Num_T >
Vec< Num_T > | operator- (const Vec< Num_T > &v, Num_T t)
| Subtraction of a scalar from a vector.
template<class Num_T >
Vec< Num_T > | operator- (Num_T t, const Vec< Num_T > &v)
| Subtraction of vector from scalar. Results in a vector.
template<class Num_T >
Vec< Num_T > | operator- (const Vec< Num_T > &v)
| Negation of vector.
template<class Num_T >
Num_T | dot (const Vec< Num_T > &v1, const Vec< Num_T > &v2)
| Inner (dot) product of two vectors v1 and v2.
template<class Num_T >
Num_T | operator* (const Vec< Num_T > &v1, const Vec< Num_T > &v2)
| Inner (dot) product of two vectors v1 and v2.
template<class Num_T >
Mat< Num_T > | outer_product (const Vec< Num_T > &v1, const Vec< Num_T > &v2, bool hermitian=false)
| Outer product of two vectors v1 and v2.
template<class Num_T >
Vec< Num_T > | operator* (const Vec< Num_T > &v, Num_T t)
| Multiplication of a vector and a scalar.
template<class Num_T >
Vec< Num_T > | operator* (Num_T t, const Vec< Num_T > &v)
| Multiplication of a scalar and a vector. Results in a vector.
template<class Num_T >
Vec< Num_T > | elem_mult (const Vec< Num_T > &a, const Vec< Num_T > &b)
| Element-wise multiplication of two vectors.
template<class Num_T >
Vec< Num_T > | elem_mult (const Vec< Num_T > &a, const Vec< Num_T > &b, const Vec< Num_T > &c)
| Element-wise multiplication of three vectors.
template<class Num_T >
Vec< Num_T > | elem_mult (const Vec< Num_T > &a, const Vec< Num_T > &b, const Vec< Num_T > &c, const Vec< Num_T > &d)
| Element-wise multiplication of four vectors.
template<class Num_T >
void | elem_mult_out (const Vec< Num_T > &a, const Vec< Num_T > &b, Vec< Num_T > &out)
| Element-wise multiplication of two vectors, storing the result in vector `out`.
template<class Num_T >
void | elem_mult_out (const Vec< Num_T > &a, const Vec< Num_T > &b, const Vec< Num_T > &c, Vec< Num_T > &out)
| Element-wise multiplication of three vectors, storing the result in vector `out`.
template<class Num_T >
void | elem_mult_out (const Vec< Num_T > &a, const Vec< Num_T > &b, const Vec< Num_T > &c, const Vec< Num_T > &d, Vec< Num_T > &out)
| Element-wise multiplication of four vectors, storing the result in vector `out`.
template<class Num_T >
void | elem_mult_inplace (const Vec< Num_T > &a, Vec< Num_T > &b)
| In-place element-wise multiplication of two vectors. Faster version of b = elem_mult(a,b).
template<class Num_T >
Num_T | elem_mult_sum (const Vec< Num_T > &a, const Vec< Num_T > &b)
| Element-wise multiplication of two vectors, followed by summation of the resultant elements. Fast version of sum(elem_mult(a,b)).
template<class Num_T >
Vec< Num_T > | operator/ (const Vec< Num_T > &v, Num_T t)
| Division of all elements in `v` with `t`.
template<class Num_T >
Vec< Num_T > | operator/ (Num_T t, const Vec< Num_T > &v)
| Division of `t` with all elements in `v`.
template<class Num_T >
Vec< Num_T > | elem_div (const Vec< Num_T > &a, const Vec< Num_T > &b)
| Elementwise division of two vectors.
template<class Num_T >
Vec< Num_T > | elem_div (Num_T t, const Vec< Num_T > &v)
| This function is deprecated. Please use operator/(Num_T, const Vec<Num_T &) instead.
template<class Num_T >
void | elem_div_out (const Vec< Num_T > &a, const Vec< Num_T > &b, Vec< Num_T > &out)
| Elementwise division of two vectors, storing the result in vector `out`.
template<class Num_T >
Num_T | elem_div_sum (const Vec< Num_T > &a, const Vec< Num_T > &b)
| Elementwise division of two vectors, followed by summation of the resultant elements. Fast version of sum(elem_div(a,b))
template<class Num_T >
Vec< Num_T > | concat (const Vec< Num_T > &v, Num_T a)
| Append element `a` to the end of the vector `v`.
template<class Num_T >
Vec< Num_T > | concat (Num_T a, const Vec< Num_T > &v)
| Concat element `a` to the beginning of the vector `v`.
template<class Num_T >
Vec< Num_T > | concat (const Vec< Num_T > &v1, const Vec< Num_T > &v2)
| Concat vectors `v1` and `v2`.
template<class Num_T >
Vec< Num_T > | concat (const Vec< Num_T > &v1, const Vec< Num_T > &v2, const Vec< Num_T > &v3)
| Concat vectors `v1`, `v2` and `v3`.
template<class Num_T >
Vec< Num_T > | concat (const Vec< Num_T > &v1, const Vec< Num_T > &v2, const Vec< Num_T > &v3, const Vec< Num_T > &v4)
| Concat vectors `v1`, `v2`, `v3` and `v4`.
template<class Num_T >
Vec< Num_T > | concat (const Vec< Num_T > &v1, const Vec< Num_T > &v2, const Vec< Num_T > &v3, const Vec< Num_T > &v4, const Vec< Num_T > &v5)
| Concat vectors `v1`, `v2` `v3`, `v4` and `v5`.
bool | chol (const mat &X, mat &F)
| Cholesky factorisation of real symmetric and positive definite matrix.
bool | chol (const cmat &X, cmat &F)
| Cholesky factorisation of complex hermitian and positive-definite matrix.
cmat | chol (const cmat &X)
| Cholesky factorisation of complex hermitian and positive-definite matrix.
mat | chol (const mat &X)
| Cholesky factorisation of real symmetric and positive definite matrix.
double | det (const mat &X)
| Determinant of real square matrix.
std::complex< double > | det (const cmat &X)
| Determinant of complex square matrix.
bool | eig_sym (const mat &A, vec &d, mat &V)
| Calculates the eigenvalues and eigenvectors of a symmetric real matrix.
bool | eig_sym (const mat &A, vec &d)
| Calculates the eigenvalues of a symmetric real matrix.
bool | eig_sym (const cmat &A, vec &d, cmat &V)
| Calculates the eigenvalues and eigenvectors of a hermitian complex matrix.
bool | eig_sym (const cmat &A, vec &d)
| Calculates the eigenvalues of a hermitian complex matrix.
bool | eig (const mat &A, cvec &d, cmat &V)
| Calculates the eigenvalues and eigenvectors of a real non-symmetric matrix.
bool | eig (const mat &A, cvec &d)
| Calculates the eigenvalues of a real non-symmetric matrix.
bool | eig (const cmat &A, cvec &d, cmat &V)
| Calculates the eigenvalues and eigenvectors of a complex non-hermitian matrix.
bool | eig (const cmat &A, cvec &d)
| Calculates the eigenvalues of a complex non-hermitian matrix.
vec | eig_sym (const mat &A)
| Calculates the eigenvalues of a symmetric real matrix.
vec | eig_sym (const cmat &A)
| Calculates the eigenvalues of a hermitian complex matrix.
cvec | eig (const mat &A)
| Calculates the eigenvalues of a real non-symmetric matrix.
cvec | eig (const cmat &A)
| Calculates the eigenvalues of a complex non-hermitian matrix.
bool | inv (const mat &X, mat &Y)
| Inverse of real square matrix.
bool | inv (const cmat &X, cmat &Y)
| Inverse of complex square matrix.
cmat | inv (const cmat &X)
| Inverse of real square matrix.
mat | inv (const mat &X)
| Inverse of real square matrix.
bool | ls_solve_chol (const mat &A, const vec &b, vec &x)
| Solve linear equation system by Cholesky factorisation.
bool | ls_solve_chol (const mat &A, const mat &B, mat &X)
| Solve linear equation system by Cholesky factorisation.
bool | ls_solve_chol (const cmat &A, const cvec &b, cvec &x)
| Solve linear equation system by Cholesky factorisation.
bool | ls_solve_chol (const cmat &A, const cmat &B, cmat &X)
| Solve linear equation system by Cholesky factorisation.
vec | ls_solve_chol (const mat &A, const vec &b)
| Solve linear equation system by Cholesky factorisation.
mat | ls_solve_chol (const mat &A, const mat &B)
| Solve linear equation system by Cholesky factorisation.
cvec | ls_solve_chol (const cmat &A, const cvec &b)
| Solve linear equation system by Cholesky factorisation.
cmat | ls_solve_chol (const cmat &A, const cmat &B)
| Solve linear equation system by Cholesky factorisation.
bool | ls_solve (const mat &A, const vec &b, vec &x)
| Solve linear equation system by LU factorisation.
bool | ls_solve (const mat &A, const mat &B, mat &X)
| Solve multiple linear equations by LU factorisation.
bool | ls_solve (const cmat &A, const cvec &b, cvec &x)
| Solve linear equation system by LU factorisation.
bool | ls_solve (const cmat &A, const cmat &B, cmat &X)
| Solve multiple linear equations by LU factorisation.
vec | ls_solve (const mat &A, const vec &b)
| Solve linear equation system by LU factorisation.
mat | ls_solve (const mat &A, const mat &B)
| Solve multiple linear equations by LU factorisation.
cvec | ls_solve (const cmat &A, const cvec &b)
| Solve linear equation system by LU factorisation.
cmat | ls_solve (const cmat &A, const cmat &B)
| Solve multiple linear equations by LU factorisation.
bool | ls_solve_od (const mat &A, const vec &b, vec &x)
| Solves overdetermined linear equation systems.
bool | ls_solve_od (const mat &A, const mat &B, mat &X)
| Solves overdetermined linear equation systems.
bool | ls_solve_od (const cmat &A, const cvec &b, cvec &x)
| Solves overdetermined linear equation systems.
bool | ls_solve_od (const cmat &A, const cmat &B, cmat &X)
| Solves overdetermined linear equation systems.
vec | ls_solve_od (const mat &A, const vec &b)
| Solves overdetermined linear equation systems.
mat | ls_solve_od (const mat &A, const mat &B)
| Solves overdetermined linear equation systems.
cvec | ls_solve_od (const cmat &A, const cvec &b)
| Solves overdetermined linear equation systems.
cmat | ls_solve_od (const cmat &A, const cmat &B)
| Solves overdetermined linear equation systems.
bool | ls_solve_ud (const mat &A, const vec &b, vec &x)
| Solves underdetermined linear equation systems.
bool | ls_solve_ud (const mat &A, const mat &B, mat &X)
| Solves underdetermined linear equation systems.
bool | ls_solve_ud (const cmat &A, const cvec &b, cvec &x)
| Solves underdetermined linear equation systems.
bool | ls_solve_ud (const cmat &A, const cmat &B, cmat &X)
| Solves underdetermined linear equation systems.
vec | ls_solve_ud (const mat &A, const vec &b)
| Solves overdetermined linear equation systems.
mat | ls_solve_ud (const mat &A, const mat &B)
| Solves underdetermined linear equation systems.
cvec | ls_solve_ud (const cmat &A, const cvec &b)
| Solves overdetermined linear equation systems.
cmat | ls_solve_ud (const cmat &A, const cmat &B)
| Solves underdetermined linear equation systems.
bool | backslash (const mat &A, const vec &b, vec &x)
| A general linear equation system solver.
vec | backslash (const mat &A, const vec &b)
| A general linear equation system solver.
bool | backslash (const mat &A, const mat &B, mat &X)
| A general linear equation system solver.
mat | backslash (const mat &A, const mat &B)
| A general linear equation system solver.
bool | backslash (const cmat &A, const cvec &b, cvec &x)
| A general linear equation system solver.
cvec | backslash (const cmat &A, const cvec &b)
| A general linear equation system solver.
bool | backslash (const cmat &A, const cmat &B, cmat &X)
| A general linear equation system solver.
cmat | backslash (const cmat &A, const cmat &B)
| A general linear equation system solver.
vec | forward_substitution (const mat &L, const vec &b)
| Forward substitution of square matrix.
void | forward_substitution (const mat &L, const vec &b, vec &x)
| Forward substitution of square matrix.
vec | forward_substitution (const mat &L, int p, const vec &b)
| Forward substitution of band matrices.
void | forward_substitution (const mat &L, int p, const vec &b, vec &x)
| Forward substitution of band matrices.
vec | backward_substitution (const mat &U, const vec &b)
| Backward substitution of square matrix.
void | backward_substitution (const mat &U, const vec &b, vec &x)
| Backward substitution of square matrix.
vec | backward_substitution (const mat &U, int q, const vec &b)
| Backward substitution of band matrix.
void | backward_substitution (const mat &U, int q, const vec &b, vec &x)
| Backward substitution of band matrix.
bool | lu (const mat &X, mat &L, mat &U, ivec &p)
| LU factorisation of real matrix.
bool | lu (const cmat &X, cmat &L, cmat &U, ivec &p)
| LU factorisation of real matrix.
void | interchange_permutations (vec &b, const ivec &p)
| Makes swapping of vector b according to the interchange permutation vector p.
bmat | permutation_matrix (const ivec &p)
| Make permutation matrix P from the interchange permutation vector p.
bool | qr (const mat &A, mat &Q, mat &R)
| QR factorisation of real matrix.
bool | qr (const mat &A, mat &R)
| QR factorisation of real matrix with suppressed evaluation of Q.
bool | qr (const mat &A, mat &Q, mat &R, bmat &P)
| QR factorisation of real matrix with pivoting.
bool | qr (const cmat &A, cmat &Q, cmat &R)
| QR factorisation of a complex matrix.
bool | qr (const cmat &A, cmat &R)
| QR factorisation of complex matrix with suppressed evaluation of Q.
bool | qr (const cmat &A, cmat &Q, cmat &R, bmat &P)
| QR factorisation of a complex matrix with pivoting.
bool | schur (const mat &A, mat &U, mat &T)
| Schur decomposition of a real matrix.
bool | schur (const cmat &A, cmat &U, cmat &T)
| Schur decomposition of a complex matrix.
mat | schur (const mat &A)
| Schur decomposition of a real matrix.
cmat | schur (const cmat &A)
| Schur decomposition of a complex matrix.
bool | svd (const mat &A, vec &s)
| Get singular values `s` of a real matrix `A` using SVD.
bool | svd (const cmat &A, vec &s)
| Get singular values `s` of a complex matrix `A` using SVD.
bool | svd (const mat &A, mat &U, vec &s, mat &V)
| Perform Singular Value Decomposition (SVD) of a real matrix `A`.
bool | svd (const cmat &A, cmat &U, vec &s, cmat &V)
| Perform Singular Value Decomposition (SVD) of a complex matrix `A`.
vec | svd (const mat &A)
| Return singular values of a real matrix `A` using SVD.
vec | svd (const cmat &A)
| Return singular values of a complex matrix `A` using SVD.
vec | sqr (const cvec &x)
| Absolute square of elements.
mat | sqr (const cmat &x)
| Absolute square of elements.
vec | abs (const cvec &x)
| Absolute value.
mat | abs (const cmat &x)
| Absolute value.
double | gamma (double x)
| Deprecated gamma function - please use tgamma() instead.
vec | gamma (const vec &x)
| Deprecated gamma function for vectors. Will be changed to tgamma().
mat | gamma (const mat &x)
| Deprecated gamma function for matrices. Will be changed to tgamma().
double | fact (int index)
| Calculates factorial coefficient for index <= 170.
double | binom (int n, int k)
| Compute the binomial coefficient "n over k".
int | binom_i (int n, int k)
| Compute the binomial coefficient "n over k".
double | log_binom (int n, int k)
| Compute the base 10 logarithm of the binomial coefficient "n over k".
int | gcd (int a, int b)
| Compute the greatest common divisor (GCD) g of the elements a and b.
vec | real (const cvec &x)
| Real part of complex values.
mat | real (const cmat &x)
| Real part of complex values.
vec | imag (const cvec &x)
| Imaginary part of complex values.
mat | imag (const cmat &x)
| Imaginary part of complex values.
vec | arg (const cvec &x)
| Argument (angle)
mat | arg (const cmat &x)
| Argument (angle)
double | sqr (double x)
| Square of x.
double | sqr (const std::complex< double > &x)
| Absolute square of complex-valued x, ||x||^2.
vec | sqr (const vec &x)
| Square of elements.
mat | sqr (const mat &x)
| Square of elements.
vec | abs (const vec &x)
| Absolute value.
mat | abs (const mat &x)
| Absolute value.
ivec | abs (const ivec &x)
| Absolute value.
imat | abs (const imat &x)
| Absolute value.
double | sign (double x)
| Signum function.
vec | sign (const vec &x)
| Signum function.
mat | sign (const mat &x)
| Signum function.
double | sgn (double x)
| Signum function.
vec | sgn (const vec &x)
| Signum function.
mat | sgn (const mat &x)
| Signum function.
int | sign_i (int x)
| Signum function.
ivec | sign_i (const ivec &x)
| Signum function.
imat | sign_i (const imat &x)
| Signum function.
int | sgn_i (int x)
| Signum function.
ivec | sgn_i (const ivec &x)
| Signum function.
imat | sgn_i (const imat &x)
| Signum function.
int | sign_i (double x)
| Signum function.
vec | sqrt (const vec &x)
| Square root of the elements.
mat | sqrt (const mat &x)
| Square root of the elements.
double | rem (double x, double y)
| The reminder of the division x/y.
vec | rem (const vec &x, double y)
| Elementwise reminder of the division x/y for vec and double.
vec | rem (double x, const vec &y)
| Elementwise reminder of the division x/y for double and vec.
mat | rem (const mat &x, double y)
| Elementwise reminder of the division x/y for mat and double.
mat | rem (double x, const mat &y)
| Elementwise reminder of the division x/y for double and mat.
int | mod (int k, int n)
| Calculates the modulus, i.e. the signed reminder after division.
vec | angle (const cvec &x)
| Angle.
mat | angle (const cmat &x)
| Angle.
cvec | conj (const cvec &x)
| Conjugate of complex value.
cmat | conj (const cmat &x)
| Conjugate of complex value.
std::complex< double > | cerfc_continued_fraction (const std::complex< double > &z)
std::complex< double > | cerf_continued_fraction (const std::complex< double > &z)
| Complementary function to `cerfc_continued_fraction`.
std::complex< double > | cerf_series (const std::complex< double > &z)
std::complex< double > | cerf_rybicki (const std::complex< double > &z)
std::complex< double > | erf (const std::complex< double > &z)
| Error function for complex argument.
double | erfinv (double x)
| Inverse of error function.
double | Qfunc (double x)
| Q-function.
vec | erf (const vec &x)
| Error function.
mat | erf (const mat &x)
| Error function.
cvec | erf (const cvec &x)
| Error function.
cmat | erf (const cmat &x)
| Error function.
vec | erfinv (const vec &x)
| Inverse of error function.
mat | erfinv (const mat &x)
| Inverse of error function.
vec | erfc (const vec &x)
| Complementary error function.
mat | erfc (const mat &x)
| Complementary error function.
vec | Qfunc (const vec &x)
| Q-function.
mat | Qfunc (const mat &x)
| Q-function.
template<typename Ftn >
double | quad (Ftn f, double a, double b, double tol=std::numeric_limits< double >::epsilon())
ITPP_EXPORT double | quad (double(*f)(double), double a, double b, double tol=std::numeric_limits< double >::epsilon())
template<typename Ftn >
double | quadl (Ftn f, double a, double b, double tol=std::numeric_limits< double >::epsilon())
ITPP_EXPORT double | quadl (double(*f)(double), double a, double b, double tol=std::numeric_limits< double >::epsilon())
vec | log2 (const vec &x)
| log-2 of the elements
mat | log2 (const mat &x)
| log-2 of the elements
double | log_add (double log_a, double log_b)
| Safe substitute for `log(exp(log_a) + exp(log_b))`
double | logb (double b, double x)
| Base-b logarithm.
int | pow2i (int x)
| Calculate two to the power of x (2^x); x is integer.
double | pow2 (double x)
| Calculate two to the power of x (2^x)
double | pow2 (int x)
| Calculate two to the power of x (2^x) for large integer x.
double | pow10 (double x)
| Calculate ten to the power of x (10^x)
double | dB (double x)
| Decibel of x (10*log10(x))
double | inv_dB (double x)
| Inverse of decibel of x.
int | int2bits (int n)
| Calculate the number of bits needed to represent an integer `n`.
int | levels2bits (int n)
| Calculate the number of bits needed to represent `n` different values (levels).
double | trunc_log (double x)
| Truncated natural logarithm function.
double | trunc_exp (double x)
| Truncated exponential function.
vec | exp (const vec &x)
| Exp of the elements of a vector `x`.
cvec | exp (const cvec &x)
| Exp of the elements of a complex vector `x`.
mat | exp (const mat &m)
| Exp of the elements of a matrix `m`.
cmat | exp (const cmat &m)
| Exp of the elements of a complex matrix `m`.
vec | pow (const double x, const vec &y)
| Calculates x to the power of y (x^y)
mat | pow (const double x, const mat &y)
| Calculates x to the power of y (x^y)
vec | pow (const vec &x, const double y)
| Calculates x to the power of y (x^y)
mat | pow (const mat &x, const double y)
| Calculates x to the power of y (x^y)
vec | pow2 (const vec &x)
| Calculates two to the power of x (2^x)
vec | pow2 (const ivec &x)
| Calculates two to the power of x (2^x) for integer x.
mat | pow2 (const mat &x)
| Calculates two to the power of x (2^x)
mat | pow2 (const imat &x)
| Calculates two to the power of x (2^x) for integer x.
vec | pow10 (const vec &x)
| Calculates ten to the power of x (10^x)
mat | pow10 (const mat &x)
| Calculates ten to the power of x (10^x)
vec | log (const vec &x)
| The natural logarithm of the elements.
mat | log (const mat &x)
| The natural logarithm of the elements.
cvec | log (const cvec &x)
| The natural logarithm of the elements.
cmat | log (const cmat &x)
| The natural logarithm of the elements.
vec | log10 (const vec &x)
| log-10 of the elements
mat | log10 (const mat &x)
| log-10 of the elements
vec | logb (double b, const vec &x)
| log-b of `x`
mat | logb (double b, const mat &x)
| log-b of `x`
vec | dB (const vec &x)
| Calculates 10*log10(x)
mat | dB (const mat &x)
| Calculates 10*log10(x)
vec | inv_dB (const vec &x)
| Calulates the inverse of dB, 10^(x/10)
mat | inv_dB (const mat &x)
| Calculates the inverse of dB, 10^(x/10)
ivec | int2bits (const ivec &v)
| Calculate the number of bits needed to represent each integer in a vector.
ivec | levels2bits (const ivec &v)
| Calculate the number of bits needed to represent a numer of levels saved in a vector.
template<class T >
T | max (const Vec< T > &v)
| Maximum value of vector.
template<class T >
T | max (const Vec< T > &v, int &index)
| Maximum value of vector, also returns the index position of max value.
template<class T >
Vec< T > | max (const Mat< T > &m, int dim=1)
template<class T >
Vec< T > | max (const Mat< T > &m, ivec &index, int dim=1)
template<class T >
T | min (const Vec< T > &in)
| Minimum value of vector.
template<class T >
T | min (const Vec< T > &in, int &index)
| Minimum value of vector, also returns the index position of min value.
template<class T >
Vec< T > | min (const Mat< T > &m, int dim=1)
template<class T >
Vec< T > | min (const Mat< T > &m, ivec &index, int dim=1)
template<class T >
int | max_index (const Vec< T > &in)
| Return the postion of the maximum element in the vector.
template<class T >
void | max_index (const Mat< T > &m, int &row, int &col)
| Return the postion of the maximum element in the matrix.
template<class T >
int | min_index (const Vec< T > &in)
| Return the postion of the minimum element in the vector.
template<class T >
void | min_index (const Mat< T > &m, int &row, int &col)
| Return the postion of the minimum element in the matrix.
std::string | itpp_version ()
| Returns IT++ library version number, e.g. "3.7.1".
bool | is_bigendian ()
| Returns true if machine endianness is BIG_ENDIAN.
bool | is_int (double x)
| Return true if x is an integer.
bool | is_even (int x)
| Return true if x is an even integer.
bool | check_big_endianness ()
| This function is deprecated. Please use is_bigendian() instead.
vec | asinh (const vec &x)
| Inverse sine hyperbolic function.
mat | asinh (const mat &x)
| Inverse sine hyperbolic function.
vec | acosh (const vec &x)
| Inverse cosine hyperbolic function.
mat | acosh (const mat &x)
| Inverse cosine hyperbolic function.
vec | atanh (const vec &x)
| Inverse tan hyperbolic function.
mat | atanh (const mat &x)
| Inverse tan hyperbolic function.
double | sinc (double x)
| Sinc function: sinc(x) = sin(pi*x)/pi*x.
vec | sin (const vec &x)
| Sine function.
mat | sin (const mat &x)
| Sine function.
vec | cos (const vec &x)
| Cosine function.
mat | cos (const mat &x)
| Cosine function.
vec | tan (const vec &x)
| Tan function.
mat | tan (const mat &x)
| Tan function.
vec | asin (const vec &x)
| Inverse sine function.
mat | asin (const mat &x)
| Inverse sine function.
vec | acos (const vec &x)
| Inverse cosine function.
mat | acos (const mat &x)
| Inverse cosine function.
vec | atan (const vec &x)
| Inverse tan function.
mat | atan (const mat &x)
| Inverse tan function.
vec | sinc (const vec &x)
| Sinc function, sin(pi*x)/(pi*x)
mat | sinc (const mat &x)
| Sinc function, sin(pi*x)/(pi*x)
vec | sinh (const vec &x)
| Sine hyperbolic function.
mat | sinh (const mat &x)
| Sine hyperbolic function.
vec | cosh (const vec &x)
| Cosine hyperbolic function.
mat | cosh (const mat &x)
| Cosine hyperbolic function.
vec | tanh (const vec &x)
| Tan hyperbolic function.
mat | tanh (const mat &x)
| Tan hyperbolic function.
bmat | graycode (int m)
| Generate Gray code of blocklength m.
int | hamming_distance (const bvec &a, const bvec &b)
| Calculate the Hamming distance between a and b.
int | weight (const bvec &a)
| Calculate the Hamming weight of a.
vec | waterfilling (const vec &alpha, double P)
| Compute the water-filling solution.
int | reverse_int (int length, int in)
int | weight_int (int length, int in)
int | compare_spectra (ivec v1, ivec v2)
int | compare_spectra (ivec v1, ivec v2, vec weight_profile)
std::istream & | operator>> (std::istream &is, GF &ingf)
| Input stream operator for GF.
std::ostream & | operator<< (std::ostream &os, const GF &ingf)
| Output stream operator for GF.
std::ostream & | operator<< (std::ostream &os, const GFX &ingfx)
| Output stream operator for GFX.
GFX | divgfx (const GFX &c, const GFX &g)
| Division of two GFX (local help function)
GFX | modgfx (const GFX &a, const GFX &b)
| Modulo function of two GFX (local help function)
ITPP_EXPORT GFX | operator* (const GF &ingf, const GFX &ingfx)
| Multiplication of GF and GFX.
ITPP_EXPORT GFX | operator* (const GFX &ingfx, const GF &ingf)
| Multiplication of GFX and GF.
ITPP_EXPORT GFX | operator/ (const GFX &ingfx, const GF &ingf)
| Division of GFX by GF.
std::ostream & | operator<< (std::ostream &os, const LDPC_Code &C)
| Print some properties of the LDPC codec in plain text.
std::ostream & | operator<< (std::ostream &os, const LLR_calc_unit &lcu)
| Print some properties of the LLR calculation unit in plain text.
std::ostream & | operator<< (std::ostream &os, const Modulator_NRD &m)
| Print some properties of the MIMO modulator (mainly to aid debugging)
std::ostream & | operator<< (std::ostream &os, const Modulator_NCD &m)
| Print some properties of the MIMO modulator (mainly to aid debugging)
GFX | formal_derivate (const GFX &f)
| Local help function.
smat | wcdma_spreading_codes (int SF)
| Generates the OVSF (orthogonal variable spreading factor) spreading codes used in WCDMA.
int | calculate_uncoded_size (Punctured_Turbo_Codec &tc, int punctured_size, int &fill_bits)
ivec | wcdma_turbo_interleaver_sequence (int interleaver_size)
| Generates the interleaver sequence for the internal turbo encoder interleaver used in WCDMA.
ivec | lte_turbo_interleaver_sequence (int interleaver_size)
| Generates the interleaver sequence for the internal turbo encoder interleaver used in LTE.
int | assert_shifts (const CFix &x, const CFix &y)
| Check that x.shift==y.shift OR x==0 OR y==0 and return the shift (for the non-zero argument)
int | assert_shifts (const CFix &x, const Fix &y)
| Check that x.shift==y.shift OR x==0 OR y==0 and return the shift (for the non-zero argument)
int | assert_shifts (const CFix &x, int y)
| Check that x.shift==0 OR x==0 OR y==0 and return x.shift.
std::istream & | operator>> (std::istream &is, CFix &x)
| Input bit representation and, optionally, the shift.
std::ostream & | operator<< (std::ostream &os, const CFix &x)
| Output bit representation and, optionally, the shift.
int | assert_shifts (const Fix &x, const Fix &y)
| Check that x.shift==y.shift OR x==0 OR y==0 and return the shift (for the non-zero argument)
int | assert_shifts (const Fix &x, int y)
| Check that x.shift==0 OR x==0 OR y==0 and return x.shift.
std::istream & | operator>> (std::istream &is, Fix &x)
| Input bit representation and, optionally, the shift.
std::ostream & | operator<< (std::ostream &os, const Fix &x)
| Output bit representation and, optionally, the shift.
std::ostream & | operator<< (std::ostream &os, const output_mode &o)
| Set output mode.
template<>
void | create_elements< Fix > (Fix *&ptr, const int n, const Factory &f)
| Create an n-length array of Fix using Fix_Factory `f`.
template<>
void | create_elements< CFix > (CFix *&ptr, const int n, const Factory &f)
| Create an n-length array of CFix using Fix_Factory `f`.
template<>
ITPP_EXPORT void | create_elements< Fix > (Fix *&ptr, const int n, const Factory &f)
| Create an n-length array of Fix using Fix_Factory `f`.
template<>
ITPP_EXPORT void | create_elements< CFix > (CFix *&ptr, const int n, const Factory &f)
| Create an n-length array of CFix using Fix_Factory `f`.
const Fix_Factory | FIX1 (1, TC, WRAP)
| Fix_Factories for signed Fix/CFix with wrap-around (FIX1, FIX2, ..., FIX64)
const Fix_Factory | UFIX1 (1, US, WRAP)
| Fix_Factories for unsigned Fix/CFix with wrap-around (UFIX1, UFIX2, ..., UFIX64)
const Fix_Factory | SFIX1 (1, TC, SAT)
| Fix_Factories for unsigned Fix/CFix with wrap-around (SFIX1, SFIX2, ..., SFIX64)
const Fix_Factory | SUFIX1 (1, US, SAT)
| Fix_Factories for unsigned Fix/CFix with saturation (SUFIX1, SUFIX2, ..., SUFIX64)
vec | to_vec (const fixvec &v)
| Converts a fixvec to vec.
cvec | to_cvec (const cfixvec &v)
| Converts a cfixvec to cvec.
mat | to_mat (const fixmat &m)
| Converts a fixmat to mat.
cmat | to_cmat (const cfixmat &m)
| Converts a cfixmat to cmat.
Fix | abs (const Fix &x)
| Absolute value.
Fix | real (const CFix &x)
| Real part of complex value.
Fix | imag (const CFix &x)
| Imaginary part of complex value.
CFix | conj (const CFix &x)
| Conjugate of complex value.
template<class T >
bool | is_fix (const T &)
| Return true only if argument is of type Fix or CFix (or an Array/Vec/Mat of Fix or CFix)
template<>
bool | is_fix (const Fix &)
| Return true only if argument is of type Fix or CFix (or an Array/Vec/Mat of Fix or CFix)
template<>
bool | is_fix (const fixvec &)
| Return true only if argument is of type Fix or CFix (or an Array/Vec/Mat of Fix or CFix)
template<>
bool | is_fix (const fixmat &)
| Return true only if argument is of type Fix or CFix (or an Array/Vec/Mat of Fix or CFix)
template<>
bool | is_fix (const CFix &)
| Return true only if argument is of type Fix or CFix (or an Array/Vec/Mat of Fix or CFix)
template<>
bool | is_fix (const cfixvec &)
| Return true only if argument is of type Fix or CFix (or an Array/Vec/Mat of Fix or CFix)
template<>
bool | is_fix (const cfixmat &)
| Return true only if argument is of type Fix or CFix (or an Array/Vec/Mat of Fix or CFix)
template<class T >
bool | is_fix (const Array< T > &)
| Return true only if argument is of type Fix or CFix (or an Array/Vec/Mat of Fix or CFix)
void | set_fix (Fix &y, double x, int n)
| Set `y = x * pow2(n)` using the quantization mode of `y`.
void | set_fix (Fix &y, double x, int n, q_mode q)
| Set `y = x * pow2(n)` using the specified quantization mode `q`.
void | set_fix (fixvec &y, const vec &x, int n)
| Set `y = x * pow2(n)` using the quantization mode of `y`.
void | set_fix (fixvec &y, const vec &x, int n, q_mode q)
| Set `y = x * pow2(n)` using the specified quantization mode `q`.
void | set_fix (fixmat &y, const mat &x, int n)
| Set `y = x * pow2(n)` using the quantization mode of `y`.
void | set_fix (fixmat &y, const mat &x, int n, q_mode q)
| Set `y = x * pow2(n)` using the specified quantization mode `q`.
void | set_fix (double &y, double x, int)
| Set `y = x`. Useful in templated code.
void | set_fix (double &y, double x, int, q_mode)
| Set `y = x`. Useful in templated code.
void | set_fix (vec &y, const vec &x, int)
| Set `y = x`. Useful in templated code.
void | set_fix (vec &y, const vec &x, int, q_mode)
| Set `y = x`. Useful in templated code.
void | set_fix (mat &y, const mat &x, int)
| Set `y = x`. Useful in templated code.
void | set_fix (mat &y, const mat &x, int, q_mode)
| Set `y = x`. Useful in templated code.
void | set_fix (CFix &y, std::complex< double > x, int n)
| Set `y = x * pow2(n)` using the quantization mode of `y`.
void | set_fix (CFix &y, double real, double imag, int n)
| Set `y = (real + i*imag) * pow2(n)` using the quantization mode of `y`.
void | set_fix (CFix &y, std::complex< double > x, int n, q_mode q)
| Set `y = x * pow2(n)` using the specified quantization mode `q`.
void | set_fix (CFix &y, double real, double imag, int n, q_mode q)
| Set `y = (real + i*imag) * pow2(n)` using the specified quantization mode `q`.
void | set_fix (cfixvec &y, const cvec &x, int n)
| Set `y = x * pow2(n)` using the quantization mode of `y`.
void | set_fix (cfixvec &y, const vec &real, const vec &imag, int n)
| Set `y = (real + i*imag) * pow2(n)` using the quantization mode of `y`.
void | set_fix (cfixvec &y, const cvec &x, int n, q_mode q)
| Set `y = x * pow2(n)` using the specified quantization mode `q`.
void | set_fix (cfixvec &y, const vec &real, const vec &imag, int n, q_mode q)
| Set `y = (real + i*imag) * pow2(n)` using the specified quantization mode `q`.
void | set_fix (cfixmat &y, const cmat &x, int n)
| Set `y = x * pow2(n)` using the quantization mode of `y`.
void | set_fix (cfixmat &y, const mat &real, const mat &imag, int n)
| Set `y = (real + i*imag) * pow2(n)` using the quantization mode of `y`.
void | set_fix (cfixmat &y, const cmat &x, int n, q_mode q)
| Set `y = x * pow2(n)` using the specified quantization mode `q`.
void | set_fix (cfixmat &y, const mat &real, const mat &imag, int n, q_mode q)
| Set `y = (real + i*imag) * pow2(n)` using the specified quantization mode `q`.
void | set_fix (std::complex< double > &y, const std::complex< double > &x, int)
| Set `y = x`. Useful in templated code.
void | set_fix (std::complex< double > &y, double real, double imag, int)
| Set `y = real + i*imag`. Useful in templated code.
void | set_fix (std::complex< double > &y, const std::complex< double > &x, int, q_mode)
| Set `y = x`. Useful in templated code.
void | set_fix (std::complex< double > &y, double real, double imag, int, q_mode)
| Set `y = real + i*imag`. Useful in templated code.
void | set_fix (cvec &y, const cvec &x, int)
| Set `y = x`. Useful in templated code.
void | set_fix (cvec &y, const vec &real, const vec &imag, int)
| Set `y = real + i*imag`. Useful in templated code.
void | set_fix (cvec &y, const cvec &x, int, q_mode)
| Set `y = x`. Useful in templated code.
void | set_fix (cvec &y, const vec &real, const vec &imag, int, q_mode)
| Set `y = real + i*imag`. Useful in templated code.
void | set_fix (cmat &y, const cmat &x, int)
| Set `y = x`. Useful in templated code.
void | set_fix (cmat &y, const mat &real, const mat &imag, int)
| Set `y = real + i*imag`. Useful in templated code.
void | set_fix (cmat &y, const cmat &x, int, q_mode)
| Set `y = x`. Useful in templated code.
void | set_fix (cmat &y, const mat &real, const mat &imag, int, q_mode)
| Set `y = real + i*imag`. Useful in templated code.
template<class T1 , class T2 >
void | set_fix (Array< T1 > &y, const Array< T2 > &x, int n)
| Call set_fix for each Array element.
template<class T1 , class T2 >
void | set_fix (Array< T1 > &y, const Array< T2 > &real, const Array< T2 > &imag, int n)
| Call set_fix for each Array element.
template<class T1 , class T2 >
void | set_fix (Array< T1 > &y, const Array< T2 > &x, int n, q_mode q)
| Call set_fix for each Array element.
template<class T1 , class T2 >
void | set_fix (Array< T1 > &y, const Array< T2 > &real, const Array< T2 > &imag, int n, q_mode q)
| Call set_fix for each Array element.
void | lshift_fix (Fix &y, int n)
| Left shift `n` bits.
void | rshift_fix (Fix &y, int n)
| Right shift `n` bits using the quantization mode of `y`.
void | rshift_fix (Fix &y, int n, q_mode q)
| Right shift `n` bits using the specified quantization mode `q`.
void | lshift_fix (fixvec &y, int n)
| Left shift `n` bits.
void | rshift_fix (fixvec &y, int n)
| Right shift `n` bits using the quantization mode of `y`.
void | rshift_fix (fixvec &y, int n, q_mode q)
| Right shift `n` bits using the specified quantization mode `q`.
void | lshift_fix (fixmat &y, int n)
| Left shift `n` bits.
void | rshift_fix (fixmat &y, int n)
| Right shift `n` bits using the quantization mode of `y`.
void | rshift_fix (fixmat &y, int n, q_mode q)
| Right shift `n` bits using the specified quantization mode `q`.
void | lshift_fix (double &, int)
| Dummy function useful in templated code.
void | rshift_fix (double &, int)
| Dummy function useful in templated code.
void | rshift_fix (double &, int, q_mode)
| Dummy function useful in templated code.
void | lshift_fix (vec &, int)
| Dummy function useful in templated code.
void | rshift_fix (vec &, int)
| Dummy function useful in templated code.
void | rshift_fix (vec &, int, q_mode)
| Dummy function useful in templated code.
void | lshift_fix (mat &, int)
| Dummy function useful in templated code.
void | rshift_fix (mat &, int)
| Dummy function useful in templated code.
void | rshift_fix (mat &, int, q_mode)
| Dummy function useful in templated code.
void | lshift_fix (CFix &y, int n)
| Left shift `n` bits.
void | rshift_fix (CFix &y, int n)
| Right shift `n` bits using the quantization mode of `y`.
void | rshift_fix (CFix &y, int n, q_mode q)
| Right shift `n` bits using the specified quantization mode `q`.
void | lshift_fix (cfixvec &y, int n)
| Left shift `n` bits.
void | rshift_fix (cfixvec &y, int n)
| Right shift `n` bits using the quantization mode of `y`.
void | rshift_fix (cfixvec &y, int n, q_mode q)
| Right shift `n` bits using the specified quantization mode `q`.
void | lshift_fix (cfixmat &y, int n)
| Left shift `n` bits.
void | rshift_fix (cfixmat &y, int n)
| Right shift `n` bits using the quantization mode of `y`.
void | rshift_fix (cfixmat &y, int n, q_mode q)
| Right shift `n` bits using the specified quantization mode `q`.
void | lshift_fix (std::complex< double > &, int)
| Dummy function useful in templated code.
void | rshift_fix (std::complex< double > &, int)
| Dummy function useful in templated code.
void | rshift_fix (std::complex< double > &, int, q_mode)
| Dummy function useful in templated code.
void | lshift_fix (cvec &, int)
| Dummy function useful in templated code.
void | rshift_fix (cvec &, int)
| Dummy function useful in templated code.
void | rshift_fix (cvec &, int, q_mode)
| Dummy function useful in templated code.
void | lshift_fix (cmat &, int)
| Dummy function useful in templated code.
void | rshift_fix (cmat &, int)
| Dummy function useful in templated code.
void | rshift_fix (cmat &, int, q_mode)
| Dummy function useful in templated code.
template<class T >
void | lshift_fix (Array< T > &y, int n)
| Call lshift_fix for each Array element.
template<class T >
void | rshift_fix (Array< T > &y, int n)
| Call rshift_fix for each Array element.
template<class T >
void | rshift_fix (Array< T > &y, int n, q_mode q)
| Call rshift_fix for each Array element.
void | assert_fixshift (double, int)
| If x is a fixed-point variable, assert that x has the specified shift value, otherwise do nothing.
void | assert_fixshift (const std::complex< double > &, int)
| If x is a fixed-point variable, assert that x has the specified shift value, otherwise do nothing.
void | assert_fixshift (const Fix &x, int shift)
| If x is a fixed-point variable, assert that x has the specified shift value, otherwise do nothing.
void | assert_fixshift (const CFix &x, int shift)
| If x is a fixed-point variable, assert that x has the specified shift value, otherwise do nothing.
template<class T >
T | to (double x)
| Convert double to T.
template<class T >
T | to (const Fix &x)
| Convert Fix to T.
template<class T >
T | to (const std::complex< double > &x)
| Convert std::complex<double> to T.
template<class T >
T | to (const CFix &x)
| Convert CFix to T.
template<class T >
T | to (double real, double imag)
| Convert double (real and imaginary parts) to T.
template<class T >
T | to (const Fix &real, const Fix &imag)
| Convert Fix (real and imaginary parts) to T.
template<class T , class U >
Vec< T > | to (const Vec< U > &x)
| Convert Vec to Vec<T>
template<>
vec | to< double > (const vec &x)
| Convert vec to vec.
template<>
cvec | to< std::complex< double > > (const cvec &x)
| Convert cvec to cvec.
template<>
fixvec | to< Fix > (const fixvec &x)
| Convert fixvec to fixvec.
template<>
cfixvec | to< CFix > (const cfixvec &x)
| Convert cfixvec to cfixvec.
template<class T , class U >
Vec< T > | to (const Vec< U > &real, const Vec< U > &imag)
| Convert Vec (real and imaginary parts) to Vec<T>
template<class T , class U >
Mat< T > | to (const Mat< U > &x)
| Convert Mat to Mat<T>
template<>
mat | to< double > (const mat &x)
| Convert mat to mat.
template<>
cmat | to< std::complex< double > > (const cmat &x)
| Convert cmat to cmat.
template<>
fixmat | to< Fix > (const fixmat &x)
| Convert fixmat to fixmat.
template<>
cfixmat | to< CFix > (const cfixmat &x)
| Convert cfixmat to cfixmat.
template<class T , class U >
Mat< T > | to (const Mat< U > &real, const Mat< U > &imag)
| Convert Mat (real and imaginary parts) to Mat<T>
template<class T , class U >
Array< typename ConvertU2T< T, U >::result > | to (const Array< U > &x)
| Convert Array , where U can be an Array/Vec/Mat, to a corresponding Array with T elements.
template<class T , class U >
Array< typename ConvertU2T< T, U >::result > | to (const Array< U > &real, const Array< U > &imag)
| Convert Array (real and imaginary parts), where U can be an Array/Vec/Mat, to a corresponding Array with T elements.
double | unfix (const Fix &x)
| Convert Fix to double by multiplying the bit representation with pow2(-shift)
std::complex< double > | unfix (const CFix &x)
| Convert CFix to std::complex<double> by multiplying the bit representation with pow2(-shift)
vec | unfix (const fixvec &x)
| Convert fixvec to vec by multiplying the bit representations with pow2(-shift)
cvec | unfix (const cfixvec &x)
| Convert cfixvec to cvec by multiplying the bit representations with pow2(-shift)
mat | unfix (const fixmat &x)
| Convert fixmat to mat by multiplying the bit representations with pow2(-shift)
cmat | unfix (const cfixmat &x)
| Convert cfixmat to cmat by multiplying the bit representations with pow2(-shift)
double | unfix (double x)
| Convert double to double i.e. do nothing.
std::complex< double > | unfix (const std::complex< double > &x)
| Convert std::complex<double> to std::complex<double> i.e. do nothing.
vec | unfix (const vec &x)
| Convert vec to vec i.e. do nothing.
cvec | unfix (const cvec &x)
| Convert cvec to cvec i.e. do nothing.
mat | unfix (const mat &x)
| Convert mat to mat i.e. do nothing.
cmat | unfix (const cmat &x)
| Convert cmat to cmat i.e. do nothing.
template<class T >
Array< typename Convert< T >::to_double > | unfix (const Array< T > &x)
| Convert floating- or fixed-point Array to floating-point Array.
Fix | operator+ (const Fix &x, const Fix &y)
| Fix + Fix.
Fix | operator- (const Fix &x, const Fix &y)
| Fix - Fix.
Fix | operator* (const Fix &x, const Fix &y)
| Fix * Fix.
Fix | operator/ (const Fix &x, const Fix &y)
| Fix / Fix using quantization mode `TRN`.
Fix | operator+ (const Fix &x, const int y)
| Fix + int.
Fix | operator- (const Fix &x, const int y)
| Fix - int.
Fix | operator* (const Fix &x, const int y)
| Fix * int.
Fix | operator/ (const Fix &x, const int y)
| Fix / int using quantization mode `TRN`.
Fix | operator+ (const int x, const Fix &y)
| int + Fix
Fix | operator- (const int x, const Fix &y)
| int - Fix
Fix | operator* (const int x, const Fix &y)
| int * Fix
Fix | operator/ (const int x, const Fix &y)
| int / Fix using quantization mode `TRN`
fixvec | operator+ (const fixvec &a, const ivec &b)
| fixvec + ivec
Fix | operator* (const fixvec &a, const ivec &b)
| fixvec * ivec
fixmat | operator+ (const fixmat &a, const imat &b)
| fixmat + imat
fixmat | operator* (const fixmat &a, const imat &b)
| fixmat * imat
CFix | operator+ (const CFix &x, const CFix &y)
| CFix + CFix.
CFix | operator- (const CFix &x, const CFix &y)
| CFix - CFix.
CFix | operator* (const CFix &x, const CFix &y)
| CFix * CFix.
CFix | operator/ (const CFix &x, const CFix &y)
| CFix / CFix using quantization mode `TRN`.
CFix | operator+ (const CFix &x, const Fix &y)
| CFix + Fix.
CFix | operator- (const CFix &x, const Fix &y)
| CFix - Fix.
CFix | operator* (const CFix &x, const Fix &y)
| CFix * Fix.
CFix | operator/ (const CFix &x, const Fix &y)
| CFix / Fix using quantization mode `TRN`.
CFix | operator+ (const Fix &x, const CFix &y)
| Fix + CFix.
CFix | operator- (const Fix &x, const CFix &y)
| Fix - CFix.
CFix | operator* (const Fix &x, const CFix &y)
| Fix * CFix.
CFix | operator/ (const Fix &x, const CFix &y)
| Fix / CFix using quantization mode `TRN`.
CFix | operator+ (const CFix &x, const int y)
| CFix + int.
CFix | operator- (const CFix &x, const int y)
| CFix - int.
CFix | operator* (const CFix &x, const int y)
| CFix * int.
CFix | operator/ (const CFix &x, const int y)
| CFix / int using quantization mode `TRN`.
CFix | operator+ (const int x, const CFix &y)
| int + CFix
CFix | operator- (const int x, const CFix &y)
| int - CFix
CFix | operator* (const int x, const CFix &y)
| int * CFix
CFix | operator/ (const int x, const CFix &y)
| int / CFix using quantization mode `TRN`
cfixvec | operator+ (const cfixvec &a, const fixvec &b)
| cfixvec + fixvec
CFix | operator* (const cfixvec &a, const fixvec &b)
| cfixvec * fixvec
cfixmat | operator+ (const cfixmat &a, const fixmat &b)
| cfixmat + fixmat
cfixmat | operator* (const cfixmat &a, const fixmat &b)
| cfixmat * fixmat
cfixvec | operator+ (const cfixvec &a, const ivec &b)
| cfixvec + ivec
CFix | operator* (const cfixvec &a, const ivec &b)
| cfixvec * ivec
cfixmat | operator+ (const cfixmat &a, const imat &b)
| cfixmat + imat
cfixmat | operator* (const cfixmat &a, const imat &b)
| cfixmat * imat
fixvec | operator+ (const fixvec &v, const int s)
| fixvec + int
fixvec | operator+ (const int s, const fixvec &v)
| int + fixvec
fixvec | operator- (const fixvec &v, const int s)
| fixvec - int
fixvec | operator- (const int s, const fixvec &v)
| int - fixvec
fixvec | operator* (const fixvec &v, const int s)
| fixvec * int
fixvec | operator* (const int s, const fixvec &v)
| int * fixvec
fixvec | operator/ (const fixvec &v, const int s)
| fixvec / int using quantization mode `TRN`
fixmat | operator+ (const fixmat &v, const int s)
| fixmat + int
fixmat | operator+ (const int s, const fixmat &v)
| int + fixmat
fixmat | operator- (const fixmat &v, const int s)
| fixmat - int
fixmat | operator- (const int s, const fixmat &v)
| int - fixmat
fixmat | operator* (const fixmat &v, const int s)
| fixmat * int
fixmat | operator* (const int s, const fixmat &v)
| int * fixmat
fixmat | operator/ (const fixmat &v, const int s)
| fixmat / int using quantization mode `TRN`
fixvec | operator+ (const ivec &a, const fixvec &b)
| ivec + fixvec
fixvec | operator- (const fixvec &a, const ivec &b)
| fixvec - ivec
fixvec | operator- (const ivec &a, const fixvec &b)
| ivec - fixvec
Fix | operator* (const ivec &a, const fixvec &b)
| ivec * fixvec
fixmat | operator+ (const imat &a, const fixmat &b)
| imat + fixmat
fixmat | operator- (const fixmat &a, const imat &b)
| fixmat - imat
fixmat | operator- (const imat &a, const fixmat &b)
| imat - fixmat
fixmat | operator* (const imat &a, const fixmat &b)
| imat * fixmat
cfixvec | operator+ (const fixvec &v, const CFix &s)
| fixvec + CFix
cfixvec | operator+ (const CFix &s, const fixvec &v)
| CFix + fixvec.
cfixvec | operator- (const fixvec &v, const CFix &s)
| fixvec - CFix
cfixvec | operator- (const CFix &s, const fixvec &v)
| CFix - fixvec.
cfixvec | operator* (const fixvec &v, const CFix &s)
| fixvec * CFix
cfixvec | operator* (const CFix &s, const fixvec &v)
| CFix * fixvec.
cfixvec | operator/ (const fixvec &v, const CFix &s)
| fixvec / CFix using quantization mode `TRN`
cfixmat | operator+ (const fixmat &m, const CFix &s)
| fixmat + CFix
cfixmat | operator+ (const CFix &s, const fixmat &m)
| CFix + fixmat.
cfixmat | operator- (const fixmat &m, const CFix &s)
| fixmat - CFix
cfixmat | operator- (const CFix &s, const fixmat &m)
| CFix - fixmat.
cfixmat | operator* (const fixmat &m, const CFix &s)
| fixmat * CFix
cfixmat | operator* (const CFix &s, const fixmat &m)
| CFix * fixmat.
cfixmat | operator/ (const fixmat &m, const CFix &s)
| fixmat / CFix using quantization mode `TRN`
cfixvec | operator+ (const ivec &v, const CFix &s)
| ivec + CFix
cfixvec | operator+ (const CFix &s, const ivec &v)
| CFix + ivec.
cfixvec | operator- (const ivec &v, const CFix &s)
| ivec - CFix
cfixvec | operator- (const CFix &s, const ivec &v)
| CFix - ivec.
cfixvec | operator* (const ivec &v, const CFix &s)
| ivec * CFix
cfixvec | operator* (const CFix &s, const ivec &v)
| CFix * ivec.
cfixvec | operator/ (const ivec &v, const CFix &s)
| ivec / CFix using quantization mode `TRN`
cfixmat | operator+ (const imat &m, const CFix &s)
| imat + CFix
cfixmat | operator+ (const CFix &s, const imat &m)
| CFix + imat.
cfixmat | operator- (const imat &m, const CFix &s)
| imat - CFix
cfixmat | operator- (const CFix &s, const imat &m)
| CFix - imat.
cfixmat | operator* (const imat &m, const CFix &s)
| imat * CFix
cfixmat | operator* (const CFix &s, const imat &m)
| CFix * imat.
cfixmat | operator/ (const imat &m, const CFix &s)
| imat / CFix using quantization mode `TRN`
cfixvec | operator+ (const cfixvec &v, const Fix &s)
| cfixvec + Fix
cfixvec | operator+ (const Fix &s, const cfixvec &v)
| Fix + cfixvec.
cfixvec | operator- (const cfixvec &v, const Fix &s)
| cfixvec - Fix
cfixvec | operator- (const Fix &s, const cfixvec &v)
| Fix - cfixvec.
cfixvec | operator* (const cfixvec &v, const Fix &s)
| cfixvec * Fix
cfixvec | operator* (const Fix &s, const cfixvec &v)
| Fix * cfixvec.
cfixvec | operator/ (const cfixvec &v, const Fix &s)
| cfixvec / Fix using quantization mode `TRN`
cfixmat | operator+ (const cfixmat &m, const Fix &s)
| cfixmat + Fix
cfixmat | operator+ (const Fix &s, const cfixmat &m)
| Fix + cfixmat.
cfixmat | operator- (const cfixmat &m, const Fix &s)
| cfixmat - Fix
cfixmat | operator- (const Fix &s, const cfixmat &m)
| Fix - cfixmat.
cfixmat | operator* (const cfixmat &m, const Fix &s)
| cfixmat * Fix
cfixmat | operator* (const Fix &s, const cfixmat &m)
| Fix * cfixmat.
cfixmat | operator/ (const cfixmat &m, const Fix &s)
| cfixmat / Fix using quantization mode `TRN`
cfixvec | operator+ (const cfixvec &v, const int s)
| cfixvec + int
cfixvec | operator+ (const int s, const cfixvec &v)
| int + cfixvec
cfixvec | operator- (const cfixvec &v, const int s)
| cfixvec - int
cfixvec | operator- (const int s, const cfixvec &v)
| int - cfixvec
cfixvec | operator* (const cfixvec &v, const int s)
| cfixvec * int
cfixvec | operator* (const int s, const cfixvec &v)
| int * cfixvec
cfixvec | operator/ (const cfixvec &v, const int s)
| cfixvec / int using quantization mode `TRN`
cfixmat | operator+ (const cfixmat &m, const int s)
| cfixmat + int
cfixmat | operator+ (const int s, const cfixmat &m)
| int + cfixmat
cfixmat | operator- (const cfixmat &m, const int s)
| cfixmat - int
cfixmat | operator- (const int s, const cfixmat &m)
| int - cfixmat
cfixmat | operator* (const cfixmat &m, const int s)
| cfixmat * int
cfixmat | operator* (const int s, const cfixmat &m)
| int * cfixmat
cfixmat | operator/ (const cfixmat &m, const int s)
| cfixmat / int using quantization mode `TRN`
cfixvec | operator+ (const fixvec &a, const cfixvec &b)
| fixvec + cfixvec
cfixvec | operator- (const cfixvec &a, const fixvec &b)
| cfixvec - fixvec
cfixvec | operator- (const fixvec &a, const cfixvec &b)
| fixvec - cfixvec
CFix | operator* (const fixvec &a, const cfixvec &b)
| fixvec * cfixvec
cfixmat | operator+ (const fixmat &a, const cfixmat &b)
| fixmat + cfixmat
cfixmat | operator- (const cfixmat &a, const fixmat &b)
| cfixmat - fixmat
cfixmat | operator- (const fixmat &a, const cfixmat &b)
| fixmat - cfixmat
cfixmat | operator* (const fixmat &a, const cfixmat &b)
| fixmat * cfixmat
cfixvec | operator+ (const ivec &a, const cfixvec &b)
| ivec + cfixvec
cfixvec | operator- (const cfixvec &a, const ivec &b)
| cfixvec - ivec
cfixvec | operator- (const ivec &a, const cfixvec &b)
| ivec - cfixvec
CFix | operator* (const ivec &a, const cfixvec &b)
| ivec * cfixvec
cfixmat | operator+ (const imat &a, const cfixmat &b)
| imat + cfixmat
cfixmat | operator- (const cfixmat &a, const imat &b)
| cfixmat - imat
cfixmat | operator- (const imat &a, const cfixmat &b)
| imat - cfixmat
cfixmat | operator* (const imat &a, const cfixmat &b)
| imat * cfixmat
vec | fminunc (double(*function)(const vec &), vec(*gradient)(const vec &), const vec &x0)
| Unconstrained minimization.
const Sequence_Number & | min (const Sequence_Number &n1, const Sequence_Number &n2)
| ADD DOCUMENTATION HERE.
const Sequence_Number & | max (const Sequence_Number &n1, const Sequence_Number &n2)
| ADD DOCUMENTATION HERE.
vec | fir1 (int N, double cutoff)
| Design a Nth order FIR filter with cut-off frequency `cutoff` using the window method.
void | filter_design_autocorrelation (const int N, const vec &f, const vec &m, vec &R)
| Calculate autocorrelation from the specified frequency-response (suitable for filter design)
void | modified_yule_walker (const int m, const int n, const int N, const vec &R, vec &a)
| Estimation of AR-part in an ARMA model given the autocorrelation.
void | arma_estimator (const int m, const int n, const vec &R, vec &b, vec &a)
| Estimation of ARMA model given the autocorrelation.
void | yulewalk (const int N, const vec &f, const vec &m, vec &b, vec &a)
| ARMA filter design using a least-squares fit to the specified frequency-response.
double | cheb (int n, double x)
| Chebyshev polynomial of the first kind.
vec | cheb (int n, const vec &x)
| Chebyshev polynomial of the first kind.
mat | cheb (int n, const mat &x)
| Chebyshev polynomial of the first kind.
template ITPP_EXPORT vec | repeat (const vec &v, int norepeats)
template ITPP_EXPORT cvec | repeat (const cvec &v, int norepeats)
template ITPP_EXPORT svec | repeat (const svec &v, int norepeats)
template ITPP_EXPORT ivec | repeat (const ivec &v, int norepeats)
template ITPP_EXPORT bvec | repeat (const bvec &v, int norepeats)
template ITPP_EXPORT mat | repeat (const mat &m, int norepeats)
template ITPP_EXPORT cmat | repeat (const cmat &m, int norepeats)
template ITPP_EXPORT smat | repeat (const smat &m, int norepeats)
template ITPP_EXPORT imat | repeat (const imat &m, int norepeats)
template ITPP_EXPORT bmat | repeat (const bmat &m, int norepeats)
template ITPP_EXPORT vec | upsample (const vec &v, int usf)
template ITPP_EXPORT cvec | upsample (const cvec &v, int usf)
template ITPP_EXPORT svec | upsample (const svec &v, int usf)
template ITPP_EXPORT ivec | upsample (const ivec &v, int usf)
template ITPP_EXPORT bvec | upsample (const bvec &v, int usf)
template ITPP_EXPORT mat | upsample (const mat &v, int usf)
template ITPP_EXPORT cmat | upsample (const cmat &v, int usf)
template ITPP_EXPORT smat | upsample (const smat &v, int usf)
template ITPP_EXPORT imat | upsample (const imat &v, int usf)
template ITPP_EXPORT bmat | upsample (const bmat &v, int usf)
template ITPP_EXPORT void | upsample (const vec &v, int usf, vec &u)
template ITPP_EXPORT void | upsample (const cvec &v, int usf, cvec &u)
template ITPP_EXPORT void | upsample (const svec &v, int usf, svec &u)
template ITPP_EXPORT void | upsample (const ivec &v, int usf, ivec &u)
template ITPP_EXPORT void | upsample (const bvec &v, int usf, bvec &u)
template ITPP_EXPORT void | upsample (const mat &v, int usf, mat &u)
template ITPP_EXPORT void | upsample (const cmat &v, int usf, cmat &u)
template ITPP_EXPORT void | upsample (const smat &v, int usf, smat &u)
template ITPP_EXPORT void | upsample (const imat &v, int usf, imat &u)
template ITPP_EXPORT void | upsample (const bmat &v, int usf, bmat &u)
template ITPP_EXPORT vec | lininterp (const vec &v, int usf)
template ITPP_EXPORT cvec | lininterp (const cvec &v, int usf)
template ITPP_EXPORT mat | lininterp (const mat &v, int usf)
template ITPP_EXPORT cmat | lininterp (const cmat &v, int usf)
template ITPP_EXPORT void | lininterp (const vec &v, int usf, vec &u)
template ITPP_EXPORT void | lininterp (const cvec &v, int usf, cvec &u)
template ITPP_EXPORT void | lininterp (const mat &v, int usf, mat &u)
template ITPP_EXPORT void | lininterp (const cmat &v, int usf, cmat &u)
template ITPP_EXPORT mat | lininterp (const mat &m, double f_base, double f_ups, int nrof_samples, double t_start)
template ITPP_EXPORT cmat | lininterp (const cmat &m, double f_base, double f_ups, int nrof_samples, double t_start)
template ITPP_EXPORT vec | lininterp (const vec &v, double f_base, double f_ups, int nrof_samples, double t_start)
template ITPP_EXPORT cvec | lininterp (const cvec &v, double f_base, double f_ups, int nrof_samples, double t_start)
template<class T >
Vec< T > | repeat (const Vec< T > &v, int norepeats)
| Repeat each element in the vector norepeats times in sequence.
template<class T >
Mat< T > | repeat (const Mat< T > &m, int norepeats)
| Repeats each column norepeats times in sequence.
template<class T >
void | upsample (const Vec< T > &v, int usf, Vec< T > &u)
| Upsample a vector by inserting (usf-1) zeros after each sample.
template<class T >
Vec< T > | upsample (const Vec< T > &v, int usf)
| Upsample a vector by inserting (usf-1) zeros after each sample.
template<class T >
void | upsample (const Mat< T > &v, int usf, Mat< T > &u)
| Upsample each column by inserting (usf-1) zeros after each column.
template<class T >
Mat< T > | upsample (const Mat< T > &v, int usf)
| Upsample each column by inserting (usf-1) zeros after each column.
template<class T >
void | lininterp (const Mat< T > &m, int usf, Mat< T > &u)
| Upsample each column by a factor of (usf-1) by linear interpolation.
template<class T >
Mat< T > | lininterp (const Mat< T > &m, double f_base, double f_ups, int nrof_samples, double t_start=0)
| Upsample each column of matrix m to achieve f_ups frequency using linear interpolation.
template<class T >
Mat< T > | lininterp (const Mat< T > &m, int usf)
| Upsample each column by a factor of (usf-1) by linear interpolation.
template<class T >
void | lininterp (const Vec< T > &v, int usf, Vec< T > &u)
| Upsample by a factor of (usf-1) by linear interpolation.
template<class T >
Vec< T > | lininterp (const Vec< T > &v, int usf)
| Upsample by a factor of (usf-1) by linear interpolation.
template<class T >
Vec< T > | lininterp (const Vec< T > &v, double f_base, double f_ups, int nrof_samples, double t_start=0)
| Upsample vector v to achieve f_ups frequency using linear interpolation.
cvec | xcorr (const cvec &x, const int max_lag=-1, const std::string scaleopt="none")
| Cross Correlation.
cvec | xcorr (const cvec &x, const cvec &y, const int max_lag=-1, const std::string scaleopt="none")
| Cross Correlation.
void | xcorr (const cvec &x, const cvec &y, cvec &out, const int max_lag=-1, const std::string scaleopt="none", bool autoflag=true)
| Cross Correlation.
mat | cov (const mat &X, bool is_zero_mean=false)
| Covariance matrix calculation.
vec | spectrum (const vec &v, int nfft=256, int noverlap=0)
| Power spectrum calculation.
vec | spectrum (const vec &v, const vec &w, int noverlap=0)
| Power spectrum calculation.
vec | filter_spectrum (const vec &a, int nfft=256)
| Power spectrum calculation of a filter.
vec | filter_spectrum (const vec &a, const vec &b, int nfft=256)
| Power spectrum calculation of a filter.
ITPP_EXPORT bool | have_fourier_transforms ()
| Run-time test if library is built with Fast Fourier Transforms enabled.
ITPP_EXPORT void | fft (const cvec &in, cvec &out)
| Fast Fourier Transform.
ITPP_EXPORT cvec | fft (const cvec &in)
| Fast Fourier Transform.
ITPP_EXPORT cvec | fft (const cvec &in, const int N)
| Fast Fourier Transform with zero-padding up to size N.
ITPP_EXPORT void | ifft (const cvec &in, cvec &out)
| Inverse Fast Fourier Transform.
ITPP_EXPORT cvec | ifft (const cvec &in)
| Inverse Fast Fourier Transform.
ITPP_EXPORT cvec | ifft (const cvec &in, const int N)
| Inverse Fast Fourier Transform with zero-padding up to size N.
ITPP_EXPORT void | fft_real (const vec &in, cvec &out)
| Real Fast Fourier Transform.
ITPP_EXPORT cvec | fft_real (const vec &in)
| Real Fast Fourier Transform.
ITPP_EXPORT cvec | fft_real (const vec &in, const int N)
| Real Fast Fourier Transform with zero-padding up to size N.
ITPP_EXPORT void | ifft_real (const cvec &in, vec &out)
| Inverse Real Fast Fourier Transform.
ITPP_EXPORT vec | ifft_real (const cvec &in)
| Inverse Real Fast Fourier Transform.
ITPP_EXPORT vec | ifft_real (const cvec &in, const int N)
| Inverse Real Fast Fourier Transformon with zero-padding up to size N.
ITPP_EXPORT bool | have_cosine_transforms ()
| Run-time test if library is built with cosine transforms enabled.
ITPP_EXPORT void | dct (const vec &in, vec &out)
| Discrete Cosine Transform (DCT)
ITPP_EXPORT vec | dct (const vec &in)
| Discrete Cosine Transform (DCT)
ITPP_EXPORT vec | dct (const vec &in, const int N)
| Discrete Cosine Transform (DCT) with zero-padding up to size N.
ITPP_EXPORT void | idct (const vec &in, vec &out)
| Inverse Discrete Cosine Transform (IDCT)
ITPP_EXPORT vec | idct (const vec &in)
| Inverse Discrete Cosine Transform (IDCT)
ITPP_EXPORT vec | idct (const vec &in, const int N)
| Inverse Discrete Cosine Transform (IDCT) with zero-padding up to size N.
template<class T >
Vec< T > | dht (const Vec< T > &v)
| Fast Hadamard Transform.
template<class T >
void | dht (const Vec< T > &vin, Vec< T > &vout)
| Fast Hadamard Transform.
template<class T >
void | self_dht (Vec< T > &v)
| Fast Hadamard Transform - memory efficient. Stores the result in `v`.
template<class T >
Vec< T > | dwht (const Vec< T > &v)
| Fast Walsh Hadamard Transform.
template<class T >
void | dwht (const Vec< T > &vin, Vec< T > &vout)
| Fast Walsh Hadamard Transform.
template<class T >
void | self_dwht (Vec< T > &v)
| Fast Walsh Hadamard Transform - memory efficient (result in `v`)
template<class T >
Mat< T > | dht2 (const Mat< T > &m)
| Fast 2D Hadamard Transform.
template<class T >
Mat< T > | dwht2 (const Mat< T > &m)
| Fast 2D Walsh Hadamard Transform.
template<class T >
void | bitrv (Vec< T > &out)
| Bit reverse.
vec | hamming (int size)
| Hamming window.
vec | hanning (int n)
| Hanning window.
vec | hann (int n)
| Hanning window compatible with matlab.
vec | blackman (int n)
| Blackman window.
vec | triang (int n)
| Triangular window.
vec | sqrt_win (int n)
| Square root window.
vec | chebwin (int n, double at)
| Dolph-Chebyshev window.
bool | is_valid (const Audio_Stream_Description &d)
| validity check for stream description d
vec | snd_read_channel (const char *fname, int ch=0)
| Read audio channel.
vec | snd_read_channel (const char *fname, int ch, int len, std::streamoff beg=0)
| Read len audio channel samples starting at position beg.
mat | snd_read (const char *fname)
| Read audio data.
mat | snd_read (const char *fname, int len, std::streamoff beg=0)
| Read len audio samples starting at position beg.
bool | snd_write_channel (const char *fname, const Audio_Stream_Description &descr, const vec &s, int ch=0)
| Write audio channel from vector s using stream description descr.
bool | snd_write (const char *fname, const Audio_Stream_Description &descr, const mat &s)
| Write audio data.
template<typename T , T max_abs>
T | limit_audio_sample (double s)
| Helper function for scaling and limiting of audio samples.
template<typename T , T down_scaling>
double | audio_sample_to_double (T s)
| Helper function for scaling and limiting of audio samples.
template<typename Binary_Out_Stream >
Binary_Out_Stream & | operator<< (Binary_Out_Stream &s, Sample_24 v)
| insertion operator for 24-bit PCM sample
template<typename Binary_In_Stream >
Binary_In_Stream & | operator>> (Binary_In_Stream &s, Sample_24 &v)
| extraction operator for 24-bit PCM sample
std::size_t | encoded_sample_size (Audio_Encoding e)
| Size of encoded sample based on the encoding type e.
std::pair< int16_t, int16_t > | ulaw_range ()
| G.711 u-Law compressor input range. Returns (min,max) input values in std::pair.
uint8_t | ulaw_compress (int16_t s)
| G.711 u-Law compression function. Returns encoded value for sample s.
int16_t | ulaw_expand (uint8_t s)
| G.711 u-Law expansion function. Returns decoded value for previously compressed sample s.Expansion is performed by the table look up.
std::pair< int16_t, int16_t > | alaw_range ()
| G.711 a-Law compressor input range. Returns (min,max) input values in std::pair.
uint8_t | alaw_compress (int16_t s)
| G.711 a-Law compression function. Returns encoded value for sample s.
int16_t | alaw_expand (uint8_t s)
| G.711 u-Law expansion function. Returns decoded value for previously compressed sample s.Expansion is performed by the table look up.
ITPP_EXPORT GMM | gmmtrain (Array< vec > &TrainingData, int M, int NOITER=30, bool VERBOSE=true)
ITPP_EXPORT vec | chirp (const vec &a, double factor)
| Returns a chirped version of the input vector.
ITPP_EXPORT double | sd (const vec &In1, const vec &In2)
| Spectral distortion between two vectors, in dB.
ITPP_EXPORT double | sd (const vec &In1, const vec &In2, double highestfreq)
| Spectral distortion between two vectors, in dB, up to highest frequency highestfreq.
ITPP_EXPORT vec | lerouxguegenrc (const vec &R, int order)
| Computes reflection coefficients from autocorrelation, using the Le-Roux-Guegen algorithm.
ITPP_EXPORT vec | levinson (const vec &R2, int order)
| Levinson - Levinson-Durbin recursion.
ITPP_EXPORT vec | autocorr (const vec &x, int order)
| Computes the autocorrelation function.
ITPP_EXPORT vec | lpc (const vec &x, int order)
| lpc - Linear Predictive Coefficients using autocorrelation method.
ITPP_EXPORT vec | schurrc (const vec &R, int order)
| schurrc - Schur algorithm.
ITPP_EXPORT vec | ac2rc (const vec &ac)
| ac2rc - Autocorrelation sequence to reflection coefficients conversion.
ITPP_EXPORT vec | ac2poly (const vec &ac)
| ac2poly - Autocorrelation sequence to prediction polynomial conversion.
ITPP_EXPORT vec | is2rc (const vec &is)
| is2rc - Inverse sine parameters to reflection coefficients conversion.
ITPP_EXPORT vec | lar2rc (const vec &lar)
| lar2rc - Log area ratios to reflection coefficients conversion.
ITPP_EXPORT vec | lsf2poly (const vec &lsf)
| lsf2poly - Line spectral frequencies to prediction polynomial conversion.
ITPP_EXPORT vec | poly2ac (const vec &poly)
| poly2ac - Prediction polynomial to autocorrelation sequence conversion.
ITPP_EXPORT vec | poly2lsf (const vec &poly)
| poly2lsf - Prediction polynomial to line spectral frequencies conversion.
ITPP_EXPORT vec | poly2rc (const vec &poly)
| poly2rc - Prediction polynomial to reflection coefficients conversion.
ITPP_EXPORT vec | poly2cepstrum (const vec &a)
| poly2cepstrum - Prediction polynomial to cepstrum conversion.
ITPP_EXPORT vec | poly2cepstrum (const vec &a, int num)
| poly2cepstrum - Prediction polynomial to cepstrum conversion, to the specified order.
ITPP_EXPORT vec | cepstrum2poly (const vec &c)
| cepstrum2poly - Cepstrum to prediction polynomial conversion.
ITPP_EXPORT vec | rc2ac (const vec &rc)
| rc2ac - Reflection coefficients to autocorrelation sequence conversion.
ITPP_EXPORT vec | rc2is (const vec &rc)
| rc2is - Reflection coefficients to inverse sine parameters conversion.
ITPP_EXPORT vec | rc2lar (const vec &rc)
| rc2lar - Reflection coefficients to log area ratios conversion.
ITPP_EXPORT vec | rc2poly (const vec &rc)
| rc2poly - Reflection coefficients to prediction polynomial conversion.
ITPP_EXPORT char | pnm_type (const std::string &filename)
| Determines the type of a PNM file, based on magic numbers. The returned value is a character between '1' and '6'. If an error occured, the returned value is the character '0'.
ITPP_EXPORT bool | pnm_info (const std::string &filename, char &pnm_type, int &width, int &height, int &max_val, std::string &comments)
| Retrieve some information about an pnm file.
ITPP_EXPORT bool | pgm_read (const std::string &filename, imat &m, std::string &comments)
| Read the entire graymap into the matrix m or return false if the function failed.
ITPP_EXPORT bool | pgm_read (const std::string &filename, imat &m, int r1, int r2, int c1, int c2)
| Read a part of the graymap into the matrix m.
ITPP_EXPORT imat | pgm_read (const std::string &filename)
| Read a pgm file of name filename and return the corresponding matrix of integers. Return a void matrix if an error ocurred.
ITPP_EXPORT bool | pgm_write (const std::string &filename, const imat &m, const std::string &comments="Generated by IT++ (http://itpp.sourceforge.net)")
| Create an image file from the matrix of integer.
ITPP_EXPORT bool | ppm_read (const std::string &filename, imat &r, imat &g, imat &b, std::string &comments)
| Read the color image file in the format ppm. The image is retrieved as a set of three matrices, each of whom is a plan of RGB component.
ITPP_EXPORT bool | ppm_read (const std::string &filename, imat &r, imat &g, imat &b)
| Read the color image file in the PPM format.
ITPP_EXPORT bool | ppm_read (const std::string &filename, imat &r, imat &g, imat &b, int r1, int r2, int c1, int c2)
| Read a part of the pixmap into the matrix m. The parameters r1, r2, c1 and c2 are the rows and columns (inclusive) of the subimage.
ITPP_EXPORT bool | ppm_write (const std::string &filename, const imat &r, const imat &g, const imat &b, const std::string &comments="Generated by IT++ (http://itpp.sourceforge.net)", int max_val=255)
| Write the matrix m as a pixmap.
ITPP_EXPORT imat | img_double2int (const mat &m, int max_val=255, double double_min=0, double double_max=1)
| Prepare a matrix of double to be writted as an image.
ITPP_EXPORT mat | img_int2double (const imat &m, int max_val=255, double double_min=0, double double_max=1)
| Return a matrix of double which is a scaled version of the input matrix m of integers.
ITPP_EXPORT int | scalar_encode (double x, vec &Levels)
| ADD DOCUMENTATION HERE.
ITPP_EXPORT ivec | scalar_encode (vec &x, vec &Levels)
| ADD DOCUMENTATION HERE.
double | scalar_quantize (double x, vec &Levels)
| ADD DOCUMENTATION HERE.
vec | scalar_quantize (vec &x, vec &Levels)
| ADD DOCUMENTATION HERE.
ITPP_EXPORT double | kmeansiter (Array< vec > &DB, mat &codebook)
| ADD DOCUMENTATION HERE.
ITPP_EXPORT mat | kmeans (Array< vec > &DB, int SIZE, int NOITER=9999, bool VERBOSE=true)
| ADD DOCUMENTATION HERE.
ITPP_EXPORT mat | lbg (Array< vec > &DB, int SIZE, int NOITER=9999, bool VERBOSE=true)
| ADD DOCUMENTATION HERE.
ITPP_EXPORT mat | vqtrain (Array< vec > &DB, int SIZE, int NOITER, double STARTSTEP=0.2, bool VERBOSE=true)
| Function for vector quantization training.
ITPP_EXPORT vec | sqtrain (const vec &inDB, int SIZE)
| ADD DOCUMENTATION HERE.
ITPP_EXPORT ivec | bitalloc (const vec &variances, int nobits)
| ADD DOCUMENTATION HERE.
double | mean (const vec &v)
| The mean value.
std::complex< double > | mean (const cvec &v)
| The mean value.
double | mean (const svec &v)
| The mean value.
double | mean (const ivec &v)
| The mean value.
double | mean (const mat &m)
| The mean value.
std::complex< double > | mean (const cmat &m)
| The mean value.
double | mean (const smat &m)
| The mean value.
double | mean (const imat &m)
| The mean value.
double | norm (const cvec &v)
| Calculate the 2-norm: norm(v)=sqrt(sum(abs(v).^2))
double | norm (const cvec &v, int p)
| Calculate the p-norm: norm(v,p)=sum(abs(v).^2)^(1/p)
double | norm (const cvec &v, const std::string &s)
| Calculate the Frobenius norm for s = "fro" (equal to 2-norm)
double | norm (const mat &m, int p)
double | norm (const cmat &m, int p)
double | norm (const mat &m, const std::string &s)
| Calculate the Frobenius norm of a matrix for s = "fro".
double | norm (const cmat &m, const std::string &s)
| Calculate the Frobenius norm of a matrix for s = "fro".
double | variance (const cvec &v)
| The variance of the elements in the vector. Normalized with N-1 to be unbiased.
double | moment (const vec &x, const int r)
| Calculate the central moment of vector x.
double | skewness (const vec &x)
| Calculate the skewness excess of the input vector x.
double | kurtosisexcess (const vec &x)
| Calculate the kurtosis excess of the input vector x.
template<class T >
double | geometric_mean (const Vec< T > &v)
| The geometric mean of a vector.
template<class T >
double | geometric_mean (const Mat< T > &m)
| The geometric mean of a matrix.
template<class T >
double | median (const Vec< T > &v)
| The median.
template<class T >
double | norm (const Vec< T > &v)
| Calculate the 2-norm: norm(v)=sqrt(sum(abs(v).^2))
template<class T >
double | norm (const Vec< T > &v, int p)
| Calculate the p-norm: norm(v,p)=sum(abs(v).^2)^(1/p)
template<class T >
double | norm (const Vec< T > &v, const std::string &s)
| Calculate the Frobenius norm for s = "fro" (equal to 2-norm)
template<class T >
double | variance (const Vec< T > &v)
| The variance of the elements in the vector. Normalized with N-1 to be unbiased.
template<class T >
double | energy (const Vec< T > &v)
| Calculate the energy: squared 2-norm. energy(v)=sum(abs(v).^2)
bool | within_tolerance (double x, double xref, double tol=1e-14)
| Return true if the input value `x` is within the tolerance `tol` of the reference value `xref`.
bool | within_tolerance (std::complex< double > x, std::complex< double > xref, double tol=1e-14)
| Return true if the input value `x` is within the tolerance `tol` of the reference value `xref`.
bool | within_tolerance (const vec &x, const vec &xref, double tol=1e-14)
| Return true if the input vector `x` is elementwise within the tolerance `tol` of the reference vector `xref`.
bool | within_tolerance (const cvec &x, const cvec &xref, double tol=1e-14)
| Return true if the input vector `x` is elementwise within the tolerance `tol` of the reference vector `xref`.
bool | within_tolerance (const mat &X, const mat &Xref, double tol=1e-14)
| Return true if the input matrix `X` is elementwise within the tolerance `tol` of the reference matrix `Xref`.
bool | within_tolerance (const cmat &X, const cmat &Xref, double tol=1e-14)
| Return true if the input matrix `X` is elementwise within the tolerance `tol` of the reference matrix `Xref`.
double | kurtosis (const vec &x)
| Calculate the kurtosis of the input vector x.
void | MOG_diag_ML (MOG_diag &model_in, Array< vec > &X_in, int max_iter_in, double var_floor_in, double weight_floor_in, bool verbose_in)
void | MOG_diag_MAP (MOG_diag &, MOG_diag &, Array< vec > &, int, double, double, double, bool)
void | MOG_diag_kmeans (MOG_diag &model_in, Array< vec > &X_in, int max_iter_in, double trust_in, bool normalise_in, bool verbose_in)
vec | filter (const vec &b, const vec &a, const vec &input)
| ARMA filter function.
cvec | filter (const vec &b, const vec &a, const cvec &input)
| ARMA filter function.
cvec | filter (const cvec &b, const cvec &a, const cvec &input)
| ARMA filter function.
cvec | filter (const cvec &b, const cvec &a, const vec &input)
| ARMA filter function.
vec | filter (const vec &b, const int one, const vec &input)
| ARMA filter function.
cvec | filter (const vec &b, const int one, const cvec &input)
| ARMA filter function.
cvec | filter (const cvec &b, const int one, const cvec &input)
| ARMA filter function.
cvec | filter (const cvec &b, const int one, const vec &input)
| ARMA filter function.
vec | filter (const int one, const vec &a, const vec &input)
| ARMA filter function.
cvec | filter (const int one, const vec &a, const cvec &input)
| ARMA filter function.
cvec | filter (const int one, const cvec &a, const cvec &input)
| ARMA filter function.
cvec | filter (const int one, const cvec &a, const vec &input)
| ARMA filter function.
vec | filter (const vec &b, const vec &a, const vec &input, const vec &state_in, vec &state_out)
| ARMA filter function.
cvec | filter (const vec &b, const vec &a, const cvec &input, const cvec &state_in, cvec &state_out)
| ARMA filter function.
cvec | filter (const cvec &b, const cvec &a, const cvec &input, const cvec &state_in, cvec &state_out)
| ARMA filter function.
cvec | filter (const cvec &b, const cvec &a, const vec &input, const cvec &state_in, cvec &state_out)
| ARMA filter function.
vec | filter (const vec &b, const int one, const vec &input, const vec &state_in, vec &state_out)
| ARMA filter function.
cvec | filter (const vec &b, const int one, const cvec &input, const cvec &state_in, cvec &state_out)
| ARMA filter function.
cvec | filter (const cvec &b, const int one, const cvec &input, const cvec &state_in, cvec &state_out)
| ARMA filter function.
cvec | filter (const cvec &b, const int one, const vec &input, const cvec &state_in, cvec &state_out)
| ARMA filter function.
vec | filter (const int one, const vec &a, const vec &input, const vec &state_in, vec &state_out)
| ARMA filter function.
cvec | filter (const int one, const vec &a, const cvec &input, const cvec &state_in, cvec &state_out)
| ARMA filter function.
cvec | filter (const int one, const cvec &a, const cvec &input, const cvec &state_in, cvec &state_out)
| ARMA filter function.
cvec | filter (const int one, const cvec &a, const vec &input, const cvec &state_in, cvec &state_out)
| ARMA filter function.
void | polystab (const vec &a, vec &out)
| Polynomial Stabilization.
void | polystab (const cvec &a, cvec &out)
| Polynomial Stabilization.
vec | polystab (const vec &a)
| Polynomial Stabilization.
cvec | polystab (const cvec &a)
| Polynomial Stabilization.
void | freqz (const cvec &b, const cvec &a, const int N, cvec &h, vec &w)
| Frequency response of filter.
cvec | freqz (const cvec &b, const cvec &a, const int N)
| Frequency response of filter.
cvec | freqz (const cvec &b, const cvec &a, const vec &w)
| Frequency response of filter.
void | freqz (const vec &b, const vec &a, const int N, cvec &h, vec &w)
| Frequency response of filter.
cvec | freqz (const vec &b, const vec &a, const int N)
| Frequency response of filter.
cvec | freqz (const vec &b, const vec &a, const vec &w)
| Frequency response of filter.
void | poly (const vec &r, vec &p)
| Create a polynomial of the given roots.
void | poly (const cvec &r, cvec &p)
| Create a polynomial of the given roots.
vec | poly (const vec &r)
| Create a polynomial of the given roots.
cvec | poly (const cvec &r)
| Create a polynomial of the given roots.
void | roots (const vec &p, cvec &r)
| Calculate the roots of the polynomial.
void | roots (const cvec &p, cvec &r)
| Calculate the roots of the polynomial.
cvec | roots (const vec &p)
| Calculate the roots of the polynomial.
cvec | roots (const cvec &p)
| Calculate the roots of the polynomial.
vec | polyval (const vec &p, const vec &x)
| Evaluate polynomial.
cvec | polyval (const vec &p, const cvec &x)
| Evaluate polynomial.
cvec | polyval (const cvec &p, const vec &x)
| Evaluate polynomial.
cvec | polyval (const cvec &p, const cvec &x)
| Evaluate polynomial.
vec | xcorr_old (const vec &x, const int max_lag=-1, const std::string scaleopt="none")
| Auto-correlation calculation.
vec | xcorr (const vec &x, const int max_lag, const std::string scaleopt)
| Auto-correlation calculation.
vec | xcorr (const vec &x, const vec &y, const int max_lag, const std::string scaleopt)
| Cross-correlation calculation.
vec | xcorr_old (const vec &x, const vec &y, const int max_lag=-1, const std::string scaleopt="none")
| Cross-correlation calculation.
void | xcorr (const vec &x, const vec &y, vec &out, const int max_lag, const std::string scaleopt)
| Cross-correlation calculation.
void | xcorr_old (const vec &x, const vec &y, vec &out, const int max_lag=-1, const std::string scaleopt="none")
| Cross-correlation calculation.

## Variables

const Factory | DEFAULT_FACTORY
| Default (dummy) factory.
Real_Timer | __tic_toc_timer
| Global object for tic and toc functions.
const double | log_double_max = std::log(std::numeric_limits<double>::max())
| Constant definition to speed up trunc_log() and trunc_exp()
const double | log_double_min = std::log(std::numeric_limits<double>::min())
| Constant definition to speed up trunc_log(), trunc_exp() and log_add()
const double | pi = 3.14159265358979323846
| Constant Pi.
const double | m_2pi = 2 * pi
| Constant 2*Pi.
const double | eps = std::numeric_limits<double>::epsilon()
| Constant eps.
template class ITPP_EXPORT | Block_Interleaver< double >
template class ITPP_EXPORT | Block_Interleaver< short >
template class ITPP_EXPORT | Block_Interleaver< int >
template class ITPP_EXPORT | Block_Interleaver< bin >
template class ITPP_EXPORT | Cross_Interleaver< double >
template class ITPP_EXPORT | Cross_Interleaver< short >
template class ITPP_EXPORT | Cross_Interleaver< int >
template class ITPP_EXPORT | Cross_Interleaver< bin >
template class ITPP_EXPORT | Sequence_Interleaver< double >
template class ITPP_EXPORT | Sequence_Interleaver< short >
template class ITPP_EXPORT | Sequence_Interleaver< int >
template class ITPP_EXPORT | Sequence_Interleaver< bin >
static const int | LDPC_binary_file_version = 2
| Version of the binary file with generator and decoder data.
template class ITPP_EXPORT | Pulse_Shape< double, double, double >
template class ITPP_EXPORT | Root_Raised_Cosine< double >
template class ITPP_EXPORT | Raised_Cosine< double >
double(* | com_log )(double, double) = NULL
| Pointer to logarithmic branch metric function.
template class ITPP_EXPORT | CFixed< 64, TC, WRAP >
const int | MAX_WORDLEN = 64
| Max word length.
const uint64_t | UINT64_POW2 [64]
| Table for fast multiplication or division by 2^n.
const double | DOUBLE_POW2 [128]
| Table for fast multiplication by 2^(n-64)
template class ITPP_EXPORT | Fixed< 64, TC, WRAP >
template class ITPP_EXPORT | MA_Filter< double, double, double >
template class ITPP_EXPORT | AR_Filter< double, double, double >
template class ITPP_EXPORT | ARMA_Filter< double, double, double >

## Detailed Description

itpp namespace

## Typedef Documentation

## GF2vec_sparse

typedef Sparse_Vec<bin> itpp::GF2vec_sparse

Sparse GF(2) vector.

Definition at line 74 of file gf2mat.h.

## GF2mat_sparse

typedef Sparse_Mat<bin> itpp::GF2mat_sparse

Sparse GF(2) matrix.

Definition at line 77 of file gf2mat.h.

## cfixed1

typedef CFixed< 1, TC, WRAP > itpp::cfixed1

Typedefs for CFixed (cfixed1, cfixed2, ..., cfixed64)

Typedefs for saturated CFixed (scfixed1, scfixed2, ..., scfixed64)

Definition at line 105 of file cfixed.h.

## fixed1

typedef Fixed<1, TC, WRAP> itpp::fixed1

Typedefs for Fixed (fixed1, fixed2, ..., fixed64)

Definition at line 81 of file fixed.h.

## ufixed1

typedef Fixed<1, US, WRAP> itpp::ufixed1

Typedefs for unsigned Fixed (ufixed1, ufixed2, ..., ufixed64)

Definition at line 149 of file fixed.h.

## sfixed1

typedef Fixed<1, TC, SAT> itpp::sfixed1

Typedefs for saturated Fixed (sfixed1, sfixed2, ..., sfixed64)

Definition at line 217 of file fixed.h.

## sufixed1

typedef Fixed<1, US, SAT> itpp::sufixed1

Typedefs for saturated unsigned Fixed (sufixed1, sufixed2, ..., sufixed64)

Definition at line 285 of file fixed.h.

## Ttype

typedef double itpp::Ttype

64-bit floating point time

Definition at line 54 of file events.h.

## Enumeration Type Documentation

## SORTING_METHOD

enum itpp::SORTING_METHOD

Sorting algorithms that can be used in a Sort class.

- Introsort (the default and the fastest method in most cases)
- Quicksort
- Heapsort
- Insertion Sort (suitable for very short vectors)

Definition at line 48 of file sort.h.

## CHANNEL_PROFILE

enum itpp::CHANNEL_PROFILE

Predefined channel profiles. Includes LOS and Doppler spectrum settings.

Definition at line 193 of file channel.h.

## FADING_TYPE

enum itpp::FADING_TYPE

Fading generator type: Independent (default), Static or Correlated.

Definition at line 203 of file channel.h.

## CORRELATED_METHOD

enum itpp::CORRELATED_METHOD

Correlated fading generation methods: Rice_MEDS (default), IFFT or FIR.

Definition at line 206 of file channel.h.

## RICE_METHOD

enum itpp::RICE_METHOD

Rice fading generation methods: MEDS.

Definition at line 209 of file channel.h.

## DOPPLER_SPECTRUM

enum itpp::DOPPLER_SPECTRUM

Predefined Doppler spectra.

Definition at line 212 of file channel.h.

## Newton_Search_Method

enum itpp::Newton_Search_Method

Newton Search method.

Definition at line 49 of file newton_search.h.

## Line_Search_Method

enum itpp::Line_Search_Method

Line Search method.

Definition at line 182 of file newton_search.h.

## Function Documentation

## concat() [1/10]

template<class T >

const Array< T > itpp::concat | ( | const Array< T > & | a,
|  | const T & | e
| ) |  |

Append element `e` to the end of the Array `a`.

Definition at line 486 of file array.h.

Referenced by arma_estimator(), chebwin(), itpp::CRC_Code::check_parity(), itpp::LDPC_Parity_Unstructured::compute_CR(), itpp::Extended_Golay::decode(), itpp::Reed_Solomon::decode(), itpp::Turbo_Codec::decode_block(), itpp::CRC_Code::encode(), itpp::LDPC_Generator_Systematic::encode(), itpp::Turbo_Codec::encode_block(), filter_design_autocorrelation(), itpp::TDL_Channel::filter_known_channel(), itpp::TDL_Channel::filter_known_channel(), itpp::GF2mat_sparse_alist::from_sparse(), itpp::FIR_Fading_Generator::generate(), itpp::IFFT_Fading_Generator::generate_Jakes(), itpp::Gold::get_family(), graycode(), itpp::FIR_Fading_Generator::Jakes_filter(), itpp::MOG_generic::join(), itpp::BLDPC_Parity::load_base_matrix(), modified_yule_walker(), itpp::CRC_Code::parity(), roots(), roots(), itpp::QAM::set_M(), itpp::ND_UQAM::set_M(), wcdma_spreading_codes(), xcorr(), and zigzag_space().

## concat() [2/10]

template<class T >

const Array< T > itpp::concat | ( | const T & | e,
|  | const Array< T > & | a
| ) |  |

Append element `e` to the beginning of the Array `a`.

Concat element `e` to the beginning of the Array `a`.

Definition at line 498 of file array.h.

## concat() [3/10]

template<class T >

const Array< T > itpp::concat | ( | const Array< T > & | a1,
|  | const Array< T > & | a2
| ) |  |

Concat Arrays `a1` and `a2`.

Definition at line 511 of file array.h.

## concat() [4/10]

template<class T >

const Array< T > itpp::concat | ( | const Array< T > & | a1,
|  | const Array< T > & | a2,
|  | const Array< T > & | a3
| ) |  |

Concat Arrays `a1`, `a2` and `a3`.

Definition at line 524 of file array.h.

## operator<<() [1/10]

ITPP_EXPORT std::ostream & operator<< | ( | std::ostream & | output,
|  | const bin & | inbin
| ) |  |

Output stream of bin.

Definition at line 36 of file binary.cpp.

## operator>>() [1/4]

ITPP_EXPORT std::istream & operator>> | ( | std::istream & | input,
|  | bin & | outbin
| ) |  |

Input stream of bin.

Definition at line 42 of file binary.cpp.

## abs()

int abs | ( | const bin & | inbin | ) |

inline

absolute value of bin

Definition at line 174 of file binary.h.

Referenced by cerf_series(), cerfc_continued_fraction(), erf(), filter_spectrum(), filter_spectrum(), fpica(), norm(), norm(), polystab(), polystab(), itpp::Newton_Search::search(), spectrum(), spectrum(), within_tolerance(), within_tolerance(), within_tolerance(), within_tolerance(), within_tolerance(), and xcorr().

## read_endian()

template<typename T1 , typename T2 >

void itpp::read_endian | ( | T1 & | st,
|  | T2 & | data,
|  | bool | switch_endian = `false`
| ) |  |

inline

Read binary data and optionally switch endianness.

Definition at line 72 of file binfile.cpp.

## write_endian()

template<typename T1 , typename T2 >

void itpp::write_endian | ( | T1 & | st,
|  | T2 | data,
|  | bool | switch_endian = `false`
| ) |  |

inline

Write binary data and optionally switch endianness.

Definition at line 85 of file binfile.cpp.

## to_bvec()

template<class T >

bvec to_bvec | ( | const Vec< T > & | v | ) |

Converts a Vec<T> to bvec.

Definition at line 51 of file converters.h.

## to_svec()

template<class T >

svec to_svec | ( | const Vec< T > & | v | ) |

Converts a Vec<T> to svec.

Definition at line 65 of file converters.h.

## to_ivec()

template<class T >

ivec to_ivec | ( | const Vec< T > & | v | ) |

Converts a Vec<T> to ivec.

Definition at line 79 of file converters.h.

Referenced by itpp::LDPC_Parity_Unstructured::compute_CR(), itpp::LDPC_Parity::display_stats(), getSamples(), itpp::Fast_ICA::separate(), and itpp::LDPC_Code::syndrome_check().

## to_vec()

template<class T >

vec to_vec | ( | const Vec< T > & | v | ) |

Converts a Vec<T> to vec.

Definition at line 93 of file converters.h.

Referenced by itpp::TDL_Channel::calc_rms_delay_spread(), itpp::LDPC_Parity_Unstructured::compute_CR(), itpp::BERC::estimate_delay(), operator*(), operator*(), operator+(), operator+(), operator-(), operator-(), operator/(), and unfix().

## to_cvec() [1/2]

template<class T >

cvec to_cvec | ( | const Vec< T > & | v | ) |

Converts a Vec<T> to cvec.

Definition at line 107 of file converters.h.

Referenced by arma_estimator(), chebwin(), itpp::Spread_2d::despread(), itpp::Multicode_Spread_2d::despread(), filter_design_autocorrelation(), filter_spectrum(), filter_spectrum(), freqz(), freqz(), polyval(), set_fix(), set_fix(), spectrum(), spectrum(), itpp::Multicode_Spread_2d::spread(), itpp::Spread_2d::spread(), unfix(), xcorr(), xcorr(), xcorr(), and xcorr().

## to_cvec() [2/2]

template<class T >

cvec to_cvec | ( | const Vec< T > & | real,
|  | const Vec< T > & | imag
| ) |  |

Converts real and imaginary Vec<T> to cvec.

Definition at line 129 of file converters.h.

## to_bmat()

template<class T >

bmat to_bmat | ( | const Mat< T > & | m | ) |

Converts a Mat<T> to bmat.

Definition at line 168 of file converters.h.

Referenced by graycode().

## to_smat()

template<class T >

smat to_smat | ( | const Mat< T > & | m | ) |

Converts a Mat<T> to smat.

Definition at line 184 of file converters.h.

## to_imat()

template<class T >

imat to_imat | ( | const Mat< T > & | m | ) |

Converts a Mat<T> to imat.

Definition at line 200 of file converters.h.

## to_mat()

template<class T >

mat to_mat | ( | const Mat< T > & | m | ) |

Converts a Mat<T> to mat.

Definition at line 216 of file converters.h.

Referenced by operator*(), operator*(), operator+(), operator+(), operator-(), operator-(), operator/(), rank(), rank(), and unfix().

## to_cmat() [1/2]

template<class T >

cmat to_cmat | ( | const Mat< T > & | m | ) |

Converts a Mat<T> to cmat.

Definition at line 232 of file converters.h.

Referenced by arma_estimator(), itpp::Mat< Num_T >::operator*(), itpp::Mat< Num_T >::operator*(), itpp::Mat< Num_T >::operator*(), itpp::Mat< Num_T >::operator*(), itpp::Mat< Num_T >::operator*(), itpp::Mat< Num_T >::operator*(), itpp::Mat< Num_T >::operator*(), itpp::Mat< Num_T >::operator*(), set_fix(), set_fix(), and unfix().

## to_cmat() [2/2]

template<class T >

cmat to_cmat | ( | const Mat< T > & | real,
|  | const Mat< T > & | imag
| ) |  |

Converts real and imaginary Mat<T> to cmat.

Definition at line 256 of file converters.h.

## oct2bin()

ITPP_EXPORT bvec itpp::oct2bin | ( | const ivec & | octalindex,
|  | short | keepzeros = `0`
| ) |  |

Convert ivec of octal form to bvec.

Converts from ivec containing {0,1,2,...,7} to bvec containing {0,1}. Removes zeros to the left if keepzeros = 0 (default). Example: oct2bin("3 5 5 1") returns {1 1 1 0 1 1 0 1 0 0 1}.

Referenced by itpp::BCH::BCH(), itpp::LFSR::set_connections(), and itpp::LFSR::set_state().

## bin2oct()

ITPP_EXPORT ivec itpp::bin2oct | ( | const bvec & | inbits | ) |

Convert bvec to octal ivec.

Converts from bvec containing {0,1} to ivec containing {0,1,2,...,7}. Adds zeros to the left if inbits.length() is not a factor of 3. Example: bin2oct("1 1 1 0 1 1 0 1 0 0 1") returns {3 5 5 1}.

## rad_to_deg()

double itpp::rad_to_deg | ( | double | x | ) |

inline

Convert radians to degrees.

Definition at line 317 of file converters.h.

References pi.

## deg_to_rad()

double itpp::deg_to_rad | ( | double | x | ) |

inline

Convert degrees to radians.

Definition at line 319 of file converters.h.

References pi.

## ceil() [1/2]

vec itpp::ceil | ( | const vec & | x | ) |

inline

Round to nearest upper integer.

Definition at line 335 of file converters.h.

## ceil() [2/2]

mat itpp::ceil | ( | const mat & | x | ) |

inline

Round to nearest upper integer.

Definition at line 337 of file converters.h.

## ceil_i()

int itpp::ceil_i | ( | double | x | ) |

inline

The nearest larger integer.

Definition at line 339 of file converters.h.

Referenced by itpp::FIR_Fading_Generator::generate(), itpp::IFFT_Fading_Generator::generate_Jakes(), hadamard(), and xcorr().

## floor() [1/2]

vec itpp::floor | ( | const vec & | x | ) |

inline

Round to nearest lower integer.

Definition at line 346 of file converters.h.

Referenced by itpp::MOG_diag_kmeans_sup::initial_means().

## floor() [2/2]

mat itpp::floor | ( | const mat & | x | ) |

inline

Round to nearest lower integer.

Definition at line 348 of file converters.h.

## floor_i()

int itpp::floor_i | ( | double | x | ) |

inline

The nearest smaller integer.

Definition at line 350 of file converters.h.

Referenced by itpp::LDPC_Parity_Unstructured::cycle_removal_MGW(), itpp::Extended_Golay::decode(), itpp::Hamming_Code::decode(), itpp::BCH::decode(), itpp::Reed_Solomon::decode(), itpp::BCH::encode(), itpp::Extended_Golay::encode(), itpp::Hamming_Code::encode(), itpp::Reed_Solomon::encode(), filter_design_autocorrelation(), linspace_fixed_step(), mod(), itpp::I_Uniform_RNG::sample(), and itpp::GF2mat::T_fact().

## round_to_zero() [1/4]

double itpp::round_to_zero | ( | double | x,
|  | double | threshold = `1e-14`
| ) |  |

inline

Round x to zero if abs(x) is smaller than threshold.

Definition at line 358 of file converters.h.

Referenced by round_to_zero(), round_to_zero(), and round_to_zero().

## round_to_zero() [2/4]

std::complex< double > itpp::round_to_zero | ( | const std::complex< double > & | x,
|  | double | threshold = `1e-14`
| ) |  |

inline

Round each part of x smaller than threshold to zero.

Definition at line 364 of file converters.h.

References round_to_zero().

## round_to_zero() [3/4]

vec itpp::round_to_zero | ( | const vec & | x,
|  | double | threshold = `1e-14`
| ) |  |

inline

Round each element to zero if element < threshold.

Definition at line 372 of file converters.h.

References round_to_zero().

## round_to_zero() [4/4]

mat itpp::round_to_zero | ( | const mat & | x,
|  | double | threshold = `1e-14`
| ) |  |

inline

Round each element to zero if element < threshold.

Definition at line 378 of file converters.h.

References round_to_zero().

## round_to_infty() [1/4]

double itpp::round_to_infty | ( | const double | in,
|  | const double | threshold = `1e9`
| ) |  |

inline

Remove trailing digits, found after the decimal point, for numbers greater than threshold.

Definition at line 390 of file converters.h.

References round().

Referenced by round_to_infty(), round_to_infty(), and round_to_infty().

## round_to_infty() [2/4]

std::complex< double > itpp::round_to_infty | ( | const std::complex< double > & | in,
|  | const double | threshold = `1e9`
| ) |  |

inline

Remove trailing digits, found after the decimal point, for complex numbers whose real and imaginary parts are greater than threshold.

Definition at line 396 of file converters.h.

References round_to_infty().

## round_to_infty() [3/4]

vec itpp::round_to_infty | ( | const vec & | in,
|  | const double | threshold = `1e9`
| ) |  |

inline

Remove trailing digits, found after the decimal point, for vectors greater than threshold.

Definition at line 403 of file converters.h.

References round_to_infty().

## round_to_infty() [4/4]

mat itpp::round_to_infty | ( | const mat & | in,
|  | const double | threshold = `1e9`
| ) |  |

inline

Remove trailing digits, found after the decimal point, for matrices greater than threshold.

Definition at line 409 of file converters.h.

References round_to_infty().

## gray_code()

int itpp::gray_code | ( | int | x | ) |

inline

Convert to Gray Code.

Definition at line 421 of file converters.h.

Referenced by itpp::QAM::set_M(), and itpp::ND_UQAM::set_M().

## to_str() [1/2]

template<typename T >

std::string itpp::to_str | ( | const T & | i | ) |

Convert anything to string.

Parameters

  i | (Input) The value to be converted to a string

Definition at line 444 of file converters.h.

Referenced by assert_fixshift(), assert_fixshift(), itpp::TCP_Segment::set_begin(), and itpp::TCP_Segment::set_end().

## to_str() [2/2]

ITPP_EXPORT std::string itpp::to_str | ( | const double & | i,
|  | const int | precision
| ) |  |

Convert double to string.

Parameters

  [in] | i | The value to be converted to a string
  [in] | precision | The number of digits used to represent the fractional part

## copy_vector() [1/4]

void itpp::copy_vector | ( | int | n,
|  | const double * | x,
|  | double * | y
| ) |  |

Definition at line 57 of file copy_vector.cpp.

## copy_vector() [2/4]

void itpp::copy_vector | ( | int | n,
|  | const std::complex< double > * | x,
|  | std::complex< double > * | y
| ) |  |

Definition at line 61 of file copy_vector.cpp.

## copy_vector() [3/4]

void itpp::copy_vector | ( | int | n,
|  | const double * | x,
|  | int | incx,
|  | double * | y,
|  | int | incy
| ) |  |

Definition at line 79 of file copy_vector.cpp.

## copy_vector() [4/4]

void itpp::copy_vector | ( | int | n,
|  | const std::complex< double > * | x,
|  | int | incx,
|  | std::complex< double > * | y,
|  | int | incy
| ) |  |

Definition at line 84 of file copy_vector.cpp.

## swap_vector() [1/4]

void itpp::swap_vector | ( | int | n,
|  | double * | x,
|  | double * | y
| ) |  |

Definition at line 105 of file copy_vector.cpp.

## swap_vector() [2/4]

void itpp::swap_vector | ( | int | n,
|  | std::complex< double > * | x,
|  | std::complex< double > * | y
| ) |  |

Definition at line 110 of file copy_vector.cpp.

## swap_vector() [3/4]

void itpp::swap_vector | ( | int | n,
|  | double * | x,
|  | int | incx,
|  | double * | y,
|  | int | incy
| ) |  |

Definition at line 129 of file copy_vector.cpp.

## swap_vector() [4/4]

void itpp::swap_vector | ( | int | n,
|  | std::complex< double > * | x,
|  | int | incx,
|  | std::complex< double > * | y,
|  | int | incy
| ) |  |

Definition at line 134 of file copy_vector.cpp.

## scal_vector() [1/4]

void itpp::scal_vector | ( | int | n,
|  | double | alpha,
|  | double * | x
| ) |  |

Definition at line 155 of file copy_vector.cpp.

## scal_vector() [2/4]

void itpp::scal_vector | ( | int | n,
|  | std::complex< double > | alpha,
|  | std::complex< double > * | x
| ) |  |

Definition at line 163 of file copy_vector.cpp.

## scal_vector() [3/4]

void itpp::scal_vector | ( | int | n,
|  | double | alpha,
|  | double * | x,
|  | int | incx
| ) |  |

Definition at line 185 of file copy_vector.cpp.

## scal_vector() [4/4]

void itpp::scal_vector | ( | int | n,
|  | std::complex< double > | alpha,
|  | std::complex< double > * | x,
|  | int | incx
| ) |  |

Definition at line 193 of file copy_vector.cpp.

## axpy_vector() [1/4]

void itpp::axpy_vector | ( | int | n,
|  | double | alpha,
|  | const double * | x,
|  | double * | y
| ) |  |

Definition at line 218 of file copy_vector.cpp.

## axpy_vector() [2/4]

void itpp::axpy_vector | ( | int | n,
|  | std::complex< double > | alpha,
|  | const std::complex< double > * | x,
|  | std::complex< double > * | y
| ) |  |

Definition at line 231 of file copy_vector.cpp.

## axpy_vector() [3/4]

void itpp::axpy_vector | ( | int | n,
|  | double | alpha,
|  | const double * | x,
|  | int | incx,
|  | double * | y,
|  | int | incy
| ) |  |

Definition at line 261 of file copy_vector.cpp.

## axpy_vector() [4/4]

void itpp::axpy_vector | ( | int | n,
|  | std::complex< double > | alpha,
|  | const std::complex< double > * | x,
|  | int | incx,
|  | std::complex< double > * | y,
|  | int | incy
| ) |  |

Definition at line 275 of file copy_vector.cpp.

## create_elements() [1/4]

template<class T >

void itpp::create_elements | ( | T *& | ptr,
|  | int | n,
|  | const Factory & |
| ) |  |

inline

Create an n-length array of T to be used as Array, Vec or Mat elements.

Definition at line 144 of file factory.h.

Referenced by itpp::Array< T >::alloc(), itpp::Mat< Num_T >::alloc(), and itpp::Vec< Num_T >::alloc().

## create_elements< unsigned char >()

template<>

void itpp::create_elements< unsigned char > | ( | unsigned char *& | ptr,
|  | int | n,
|  | const Factory & |
| ) |  |

inline

Specialization for unsigned char data arrays (used in GF2Mat)

Definition at line 156 of file factory.h.

## create_elements< bin >()

template<>

void itpp::create_elements< bin > | ( | bin *& | ptr,
|  | int | n,
|  | const Factory & |
| ) |  |

inline

Specialization for binary data arrays.

Definition at line 165 of file factory.h.

## create_elements< short int >()

template<>

void itpp::create_elements< short int > | ( | short int *& | ptr,
|  | int | n,
|  | const Factory & |
| ) |  |

inline

Specialization for short integer data arrays.

Definition at line 173 of file factory.h.

## create_elements< int >()

template<>

void itpp::create_elements< int > | ( | int *& | ptr,
|  | int | n,
|  | const Factory & |
| ) |  |

inline

Specialization for integer data arrays.

Definition at line 181 of file factory.h.

## create_elements< double >()

template<>

void itpp::create_elements< double > | ( | double *& | ptr,
|  | int | n,
|  | const Factory & |
| ) |  |

inline

Specialization for 16-byte aligned double data arrays.

Definition at line 189 of file factory.h.

## create_elements< std::complex< double > >()

template<>

void itpp::create_elements< std::complex< double > > | ( | std::complex< double > *& | ptr,
|  | int | n,
|  | const Factory & |
| ) |  |

inline

Specialization for 16-byte aligned complex double data arrays.

Definition at line 200 of file factory.h.

## destroy_elements()

template<class T >

void itpp::destroy_elements | ( | T *& | ptr,
|  | int | n
| ) |  |

inline

Destroy an array of Array, Vec or Mat elements.

Definition at line 214 of file factory.h.

Referenced by itpp::Array< T >::free(), itpp::Mat< Num_T >::free(), itpp::Vec< Num_T >::free(), itpp::Array< T >::set_size(), itpp::Mat< Num_T >::set_size(), and itpp::Vec< Num_T >::set_size().

## destroy_elements< unsigned char >()

template<>

void itpp::destroy_elements< unsigned char > | ( | unsigned char *& | ptr,
|  | int |
| ) |  |

inline

Specialization for unsigned char data arrays (used in GF2Mat)

Definition at line 228 of file factory.h.

## destroy_elements< bin >()

template<>

void itpp::destroy_elements< bin > | ( | bin *& | ptr,
|  | int |
| ) |  |

inline

Specialization for binary data arrays.

Definition at line 239 of file factory.h.

## destroy_elements< short int >()

template<>

void itpp::destroy_elements< short int > | ( | short int *& | ptr,
|  | int |
| ) |  |

inline

Specialization for short integer data arrays.

Definition at line 249 of file factory.h.

## destroy_elements< int >()

template<>

void itpp::destroy_elements< int > | ( | int *& | ptr,
|  | int |
| ) |  |

inline

Specialization for integer data arrays.

Definition at line 260 of file factory.h.

## destroy_elements< double >()

template<>

void itpp::destroy_elements< double > | ( | double *& | ptr,
|  | int |
| ) |  |

inline

Specialisation for 16-byte aligned double data arrays.

Definition at line 271 of file factory.h.

## destroy_elements< std::complex< double > >()

template<>

void itpp::destroy_elements< std::complex< double > > | ( | std::complex< double > *& | ptr,
|  | int |
| ) |  |

inline

Specialisation for 16-byte aligned complex double data arrays.

Definition at line 282 of file factory.h.

## create_elements() [2/4]

template<class T >

void itpp::create_elements | ( | Array< T > *& | ptr,
|  | int | n,
|  | const Factory & | f
| ) |  |

Create an n-length array of Array<T> to be used as Array elements.

Definition at line 294 of file factory.h.

## create_elements() [3/4]

template<class T >

void itpp::create_elements | ( | Mat< T > *& | ptr,
|  | int | n,
|  | const Factory & | f
| ) |  |

Create an n-length array of Mat<T> to be used as Array elements.

Definition at line 305 of file factory.h.

## create_elements() [4/4]

template<class T >

void itpp::create_elements | ( | Vec< T > *& | ptr,
|  | int | n,
|  | const Factory & | f
| ) |  |

Create an n-length array of Vec<T> to be used as Array elements.

Definition at line 316 of file factory.h.

## sub_v_vT_m()

ITPP_EXPORT void sub_v_vT_m | ( | mat & | m,
|  | const vec & | v
| ) |  |

Calculates m=m-v*v'*m.

Definition at line 37 of file fastmath.cpp.

## sub_m_v_vT()

ITPP_EXPORT void sub_m_v_vT | ( | mat & | m,
|  | const vec & | v
| ) |  |

Calculates m=m-m*v*v'.

Definition at line 65 of file fastmath.cpp.

## gf2dense_eye()

ITPP_EXPORT GF2mat gf2dense_eye | ( | int | m | ) |

GF(2) Identity matrix.

Definition at line 470 of file gf2mat.cpp.

Referenced by itpp::LDPC_Generator_Systematic::construct().

## operator*() [1/72]

ITPP_EXPORT GF2mat operator* | ( | const GF2mat & | X,
|  | const GF2mat & | Y
| ) |  |

GF(2) matrix multiplication.

Multiplication operator.

Definition at line 847 of file gf2mat.cpp.

Referenced by operator*().

## operator*() [2/72]

ITPP_EXPORT bvec operator* | ( | const GF2mat & | X,
|  | const bvec & | y
| ) |  |

GF(2) matrix multiplication with "regular" binary vector.

Multiplication operator with binary vector.

Definition at line 873 of file gf2mat.cpp.

## mult_trans() [1/2]

ITPP_EXPORT GF2mat mult_trans | ( | const GF2mat & | X,
|  | const GF2mat & | Y
| ) |  |

Multiplication X*Y' where X and Y are GF(2) matrices.

Definition at line 903 of file gf2mat.cpp.

## operator+() [1/64]

ITPP_EXPORT GF2mat operator+ | ( | const GF2mat & | X,
|  | const GF2mat & | Y
| ) |  |

GF(2) matrix addition.

Addition operator.

Subtraction is not implemented because it is equivalent to addition.

Definition at line 948 of file gf2mat.cpp.

## operator<<() [2/10]

ITPP_EXPORT std::ostream & operator<< | ( | std::ostream & | os,
|  | const GF2mat & | X
| ) |  |

Output stream (plain text) operator for dense GF(2) matrices.

Output stream operator (plain text)

Definition at line 1001 of file gf2mat.cpp.

## operator<<() [3/10]

ITPP_EXPORT it_file & itpp::operator<< | ( | it_file & | f,
|  | const GF2mat & | X
| ) |  |

/relatesalso GF2mat /brief Write GF(2) matrix to file.

Definition at line 1032 of file gf2mat.cpp.

## operator>>() [2/4]

ITPP_EXPORT it_ifile & itpp::operator>> | ( | it_ifile & | f,
|  | GF2mat & | X
| ) |  |

/relatesalso GF2mat /brief Read GF(2) matrix from file.

Definition at line 1050 of file gf2mat.cpp.

## concat_horizontal()

template<class Num_T >

Mat< Num_T > itpp::concat_horizontal | ( | const Mat< Num_T > & | m1,
|  | const Mat< Num_T > & | m2
| ) |  |

Horizontal concatenation of two matrices.

Concatenate the matrices `m1` and `m2` horizontally.

Definition at line 1194 of file mat.h.

Referenced by itpp::Extended_Golay::Extended_Golay(), and fpica().

## concat_vertical()

template<class Num_T >

Mat< Num_T > itpp::concat_vertical | ( | const Mat< Num_T > & | m1,
|  | const Mat< Num_T > & | m2
| ) |  |

Vertical concatenation of two matrices.

Concatenate the matrices `m1` and `m2` vertically.

Definition at line 1216 of file mat.h.

## operator+() [2/64]

template<class Num_T >

Mat< Num_T > itpp::operator+ | ( | const Mat< Num_T > & | m1,
|  | const Mat< Num_T > & | m2
| ) |  |

Addition of two matrices.

Definition at line 1309 of file mat.h.

## operator+() [3/64]

template<class Num_T >

Mat< Num_T > itpp::operator+ | ( | const Mat< Num_T > & | m,
|  | Num_T | t
| ) |  |

Addition of a matrix and a scalar.

Addition of matrix and scalar.

Definition at line 1331 of file mat.h.

## operator+() [4/64]

template<class Num_T >

Mat< Num_T > itpp::operator+ | ( | Num_T | t,
|  | const Mat< Num_T > & | m
| ) |  |

Addition of a scalar and a matrix.

Addition of scalar and matrix.

Definition at line 1342 of file mat.h.

## operator-() [1/63]

template<class Num_T >

Mat< Num_T > itpp::operator- | ( | const Mat< Num_T > & | m1,
|  | const Mat< Num_T > & | m2
| ) |  |

Subtraction of two matrices.

Subtraction of `m2` from `m1`.

Definition at line 1382 of file mat.h.

## operator-() [2/63]

template<class Num_T >

Mat< Num_T > itpp::operator- | ( | const Mat< Num_T > & | m,
|  | Num_T | t
| ) |  |

Subtraction of matrix and scalar.

Subtraction of scalar from matrix.

Definition at line 1410 of file mat.h.

## operator-() [3/63]

template<class Num_T >

Mat< Num_T > itpp::operator- | ( | Num_T | t,
|  | const Mat< Num_T > & | m
| ) |  |

Subtraction of scalar and matrix.

Subtract matrix from scalar.

Definition at line 1427 of file mat.h.

## operator-() [4/63]

template<class Num_T >

Mat< Num_T > itpp::operator- | ( | const Mat< Num_T > & | m | ) |

Negation of matrix.

Subtraction of matrix.

Definition at line 1444 of file mat.h.

## operator*() [3/72]

template<class Num_T >

Mat< Num_T > itpp::operator* | ( | const Mat< Num_T > & | m1,
|  | const Mat< Num_T > & | m2
| ) |  |

Multiplication of two matrices.

Definition at line 1501 of file mat.h.

References it_assert_debug.

## operator*() [4/72]

template<class Num_T >

Vec< Num_T > itpp::operator* | ( | const Mat< Num_T > & | m,
|  | const Vec< Num_T > & | v
| ) |  |

Multiplication of matrix and vector.

Multiplication of matrix `m` and vector `v` (column vector)

Definition at line 1536 of file mat.h.

References it_assert_debug, and itpp::Array< T >::size().

## operator*() [5/72]

template<class Num_T >

Mat< Num_T > itpp::operator* | ( | const Mat< Num_T > & | m,
|  | Num_T | t
| ) |  |

Multiplication of matrix and scalar.

Definition at line 1562 of file mat.h.

## operator*() [6/72]

template<class Num_T >

Mat< Num_T > itpp::operator* | ( | Num_T | t,
|  | const Mat< Num_T > & | m
| ) |  |

inline

Multiplication of scalar and matrix.

Definition at line 1576 of file mat.h.

References operator*().

## elem_mult() [1/7]

template<class Num_T >

Mat< Num_T > itpp::elem_mult | ( | const Mat< Num_T > & | m1,
|  | const Mat< Num_T > & | m2
| ) |  |

inline

Element wise multiplication of two matrices.

Definition at line 1582 of file mat.h.

Referenced by arma_estimator(), itpp::Convolutional_Code::calculate_spectrum(), itpp::Punctured_Convolutional_Code::calculate_spectrum(), chebwin(), itpp::LDPC_Parity_Unstructured::compute_CR(), itpp::LDPC_Parity_Unstructured::cycle_removal_MGW(), itpp::LDPC_Parity::display_stats(), itpp::BERC::estimate_delay(), itpp::EXIT::extrinsic_mutual_info(), itpp::TDL_Channel::filter_known_channel(), itpp::TDL_Channel::filter_known_channel(), fpica(), itpp::Rice_Fading_Generator::generate(), itpp::FIR_Fading_Generator::Jakes_filter(), polyval(), polyval(), polyval(), polyval(), spectrum(), spectrum(), and xcorr().

## elem_mult_out() [1/6]

template<class Num_T >

void itpp::elem_mult_out | ( | const Mat< Num_T > & | m1,
|  | const Mat< Num_T > & | m2,
|  | Mat< Num_T > & | out
| ) |  |

Element wise multiplication of two matrices, storing the result in matrix `out`.

Definition at line 1590 of file mat.h.

## elem_mult_out() [2/6]

template<class Num_T >

void itpp::elem_mult_out | ( | const Mat< Num_T > & | m1,
|  | const Mat< Num_T > & | m2,
|  | const Mat< Num_T > & | m3,
|  | Mat< Num_T > & | out
| ) |  |

Element wise multiplication of three matrices, storing the result in matrix `out`.

Definition at line 1601 of file mat.h.

## elem_mult_out() [3/6]

template<class Num_T >

void itpp::elem_mult_out | ( | const Mat< Num_T > & | m1,
|  | const Mat< Num_T > & | m2,
|  | const Mat< Num_T > & | m3,
|  | const Mat< Num_T > & | m4,
|  | Mat< Num_T > & | out
| ) |  |

Element wise multiplication of four matrices, storing the result in matrix `out`.

Definition at line 1613 of file mat.h.

## elem_mult_inplace() [1/2]

template<class Num_T >

void itpp::elem_mult_inplace | ( | const Mat< Num_T > & | m1,
|  | Mat< Num_T > & | m2
| ) |  |

inline

In-place element wise multiplication of two matrices. Fast version of B = elem_mult(A, B).

Definition at line 1630 of file mat.h.

## elem_mult_sum() [1/2]

template<class Num_T >

Num_T itpp::elem_mult_sum | ( | const Mat< Num_T > & | m1,
|  | const Mat< Num_T > & | m2
| ) |  |

inline

Element wise multiplication of two matrices, followed by summation of the resultant elements. Fast version of sumsum(elem_mult(A, B)).

Definition at line 1639 of file mat.h.

## operator/() [1/23]

template<class Num_T >

Mat< Num_T > itpp::operator/ | ( | const Mat< Num_T > & | m,
|  | Num_T | t
| ) |  |

Element-wise division by a scalar.

Definition at line 1670 of file mat.h.

## operator/() [2/23]

template<class Num_T >

Mat< Num_T > itpp::operator/ | ( | Num_T | t,
|  | const Mat< Num_T > & | m
| ) |  |

Element-wise division (`t` is the dividend, elements of `m` are divisors)

Definition at line 1679 of file mat.h.

## elem_div() [1/3]

template<class Num_T >

Mat< Num_T > itpp::elem_div | ( | const Mat< Num_T > & | m1,
|  | const Mat< Num_T > & | m2
| ) |  |

inline

Element wise division of two matrices.

Definition at line 1688 of file mat.h.

Referenced by arma_estimator(), itpp::LDPC_Parity_Unstructured::compute_CR(), itpp::TDL_Channel::discretize(), itpp::EXIT::extrinsic_mutual_info(), filter_spectrum(), freqz(), freqz(), freqz(), and freqz().

## elem_div_out() [1/2]

template<class Num_T >

void itpp::elem_div_out | ( | const Mat< Num_T > & | m1,
|  | const Mat< Num_T > & | m2,
|  | Mat< Num_T > & | out
| ) |  |

Element wise division of two matrices, storing the result in matrix `out`.

Definition at line 1696 of file mat.h.

## elem_div_sum() [1/2]

template<class Num_T >

Num_T itpp::elem_div_sum | ( | const Mat< Num_T > & | m1,
|  | const Mat< Num_T > & | m2
| ) |  |

inline

Element wise division of two matrices, followed by summation of the resultant elements. Fast version of sumsum(elem_div(A, B)).

Definition at line 1710 of file mat.h.

## operator+() [5/64]

ITPP_EXPORT vec operator+ | ( | const double & | s,
|  | const ivec & | v
| ) |  |

Addition operator for double and ivec.

Definition at line 38 of file operators.cpp.

## operator-() [5/63]

ITPP_EXPORT vec operator- | ( | const double & | s,
|  | const ivec & | v
| ) |  |

Subtraction operator for double and ivec.

Definition at line 49 of file operators.cpp.

## operator*() [7/72]

ITPP_EXPORT vec operator* | ( | const double & | s,
|  | const ivec & | v
| ) |  |

Multiplication operator for double and ivec.

Definition at line 60 of file operators.cpp.

## operator/() [3/23]

ITPP_EXPORT vec operator/ | ( | const double & | s,
|  | const ivec & | v
| ) |  |

Division operator for double and ivec.

Definition at line 71 of file operators.cpp.

## operator/() [4/23]

ITPP_EXPORT vec operator/ | ( | const ivec & | v,
|  | const double & | s
| ) |  |

Division operator for ivec and double.

Definition at line 82 of file operators.cpp.

## operator+() [6/64]

ITPP_EXPORT cvec operator+ | ( | const std::complex< double > & | s,
|  | const ivec & | v
| ) |  |

Addition operator for complex<double> and ivec.

Definition at line 93 of file operators.cpp.

## operator-() [6/63]

ITPP_EXPORT cvec operator- | ( | const std::complex< double > & | s,
|  | const ivec & | v
| ) |  |

Subtraction operator for complex<double> and ivec.

Definition at line 104 of file operators.cpp.

## operator*() [8/72]

ITPP_EXPORT cvec operator* | ( | const std::complex< double > & | s,
|  | const ivec & | v
| ) |  |

Multiplication operator for complex<double> and ivec.

Definition at line 115 of file operators.cpp.

## operator/() [5/23]

ITPP_EXPORT cvec operator/ | ( | const std::complex< double > & | s,
|  | const ivec & | v
| ) |  |

Division operator for complex<double> and ivec.

Definition at line 126 of file operators.cpp.

## operator/() [6/23]

ITPP_EXPORT cvec operator/ | ( | const ivec & | v,
|  | const std::complex< double > & | s
| ) |  |

Division operator for ivec and complex<double>

Definition at line 137 of file operators.cpp.

## operator+() [7/64]

ITPP_EXPORT cvec operator+ | ( | const double & | s,
|  | const cvec & | v
| ) |  |

Addition operator for double and cvec.

Definition at line 150 of file operators.cpp.

## operator-() [7/63]

ITPP_EXPORT cvec operator- | ( | const double & | s,
|  | const cvec & | v
| ) |  |

Subtraction operator for double and cvec.

Definition at line 161 of file operators.cpp.

## operator*() [9/72]

ITPP_EXPORT cvec operator* | ( | const double & | s,
|  | const cvec & | v
| ) |  |

Multiplication operator for double and cvec.

Definition at line 172 of file operators.cpp.

## operator/() [7/23]

ITPP_EXPORT cvec operator/ | ( | const cvec & | v,
|  | const double & | s
| ) |  |

Division operator for cvec and double.

Definition at line 183 of file operators.cpp.

## operator/() [8/23]

ITPP_EXPORT cvec operator/ | ( | const double & | s,
|  | const cvec & | v
| ) |  |

Division operator for double and cvec.

Definition at line 194 of file operators.cpp.

## operator+() [8/64]

ITPP_EXPORT cmat operator+ | ( | const double & | s,
|  | const cmat & | m
| ) |  |

Addition operator for double and cmat.

Definition at line 207 of file operators.cpp.

## operator-() [8/63]

ITPP_EXPORT cmat operator- | ( | const double & | s,
|  | const cmat & | m
| ) |  |

Subtraction operator for double and cmat.

Definition at line 218 of file operators.cpp.

## operator*() [10/72]

ITPP_EXPORT cmat operator* | ( | const double & | s,
|  | const cmat & | m
| ) |  |

Multiplication operator for double and cmat.

Definition at line 229 of file operators.cpp.

## operator*() [11/72]

ITPP_EXPORT cmat operator* | ( | const std::complex< double > & | s,
|  | const mat & | m
| ) |  |

Multiplication operator for complex<double> and mat.

Definition at line 240 of file operators.cpp.

## operator/() [9/23]

ITPP_EXPORT cmat operator/ | ( | const cmat & | m,
|  | const double & | s
| ) |  |

Division operator for cmat and double.

Definition at line 252 of file operators.cpp.

## operator*() [12/72]

cvec operator* | ( | const std::complex< double > & | s,
|  | const vec & | v
| ) |  |

Multiplication operator for complex<double> and vec.

Definition at line 267 of file operators.cpp.

## operator*() [13/72]

cvec operator* | ( | const vec & | v,
|  | const std::complex< double > & | s
| ) |  |

Multiplication operator for vec and complex<double>

Definition at line 276 of file operators.cpp.

## operator+() [9/64]

ITPP_EXPORT vec operator+ | ( | const bvec & | a,
|  | const vec & | b
| ) |  |

Addition operator for bvec and vec.

Definition at line 290 of file operators.cpp.

## operator+() [10/64]

ITPP_EXPORT vec operator+ | ( | const svec & | a,
|  | const vec & | b
| ) |  |

Addition operator for svec and vec.

Definition at line 298 of file operators.cpp.

## operator+() [11/64]

ITPP_EXPORT vec operator+ | ( | const ivec & | a,
|  | const vec & | b
| ) |  |

Addition operator for ivec and vec.

Definition at line 306 of file operators.cpp.

## operator+() [12/64]

ITPP_EXPORT cvec operator+ | ( | const bvec & | a,
|  | const cvec & | b
| ) |  |

Addition operator for bvec and cvec.

Definition at line 314 of file operators.cpp.

## operator+() [13/64]

ITPP_EXPORT cvec operator+ | ( | const svec & | a,
|  | const cvec & | b
| ) |  |

Addition operator for svec and cvec.

Definition at line 322 of file operators.cpp.

## operator+() [14/64]

ITPP_EXPORT cvec operator+ | ( | const ivec & | a,
|  | const cvec & | b
| ) |  |

Addition operator for ivec and cvec.

Definition at line 330 of file operators.cpp.

## operator*() [14/72]

ITPP_EXPORT double operator* | ( | const bvec & | a,
|  | const vec & | b
| ) |  |

Multiplication operator for bvec and vec.

Definition at line 340 of file operators.cpp.

## operator*() [15/72]

ITPP_EXPORT double operator* | ( | const svec & | a,
|  | const vec & | b
| ) |  |

Multiplication operator for svec and vec.

Definition at line 348 of file operators.cpp.

## operator*() [16/72]

ITPP_EXPORT double operator* | ( | const ivec & | a,
|  | const vec & | b
| ) |  |

Multiplication operator for ivec and vec.

Definition at line 356 of file operators.cpp.

## operator*() [17/72]

ITPP_EXPORT std::complex< double > operator* | ( | const bvec & | a,
|  | const cvec & | b
| ) |  |

Multiplication operator for bvec and cvec.

Definition at line 364 of file operators.cpp.

## operator*() [18/72]

ITPP_EXPORT std::complex< double > operator* | ( | const svec & | a,
|  | const cvec & | b
| ) |  |

Multiplication operator for svec and cvec.

Definition at line 372 of file operators.cpp.

## operator*() [19/72]

ITPP_EXPORT std::complex< double > operator* | ( | const ivec & | a,
|  | const cvec & | b
| ) |  |

Multiplication operator for ivec and cvec.

Definition at line 380 of file operators.cpp.

## operator+() [15/64]

mat itpp::operator+ | ( | const bmat & | a,
|  | const mat & | b
| ) |  |

Addition operator for bmat and mat.

Definition at line 390 of file operators.cpp.

References it_assert_debug.

## operator+() [16/64]

ITPP_EXPORT mat operator+ | ( | const smat & | a,
|  | const mat & | b
| ) |  |

Addition operator for smat and mat.

Definition at line 403 of file operators.cpp.

## operator+() [17/64]

ITPP_EXPORT mat operator+ | ( | const imat & | a,
|  | const mat & | b
| ) |  |

Addition operator for imat and mat.

Definition at line 416 of file operators.cpp.

## operator+() [18/64]

cmat itpp::operator+ | ( | const bmat & | a,
|  | const cmat & | b
| ) |  |

Addition operator for bmat and cmat.

Definition at line 431 of file operators.cpp.

References it_assert_debug.

## operator+() [19/64]

ITPP_EXPORT cmat operator+ | ( | const smat & | a,
|  | const cmat & | b
| ) |  |

Addition operator for smat and cmat.

Definition at line 444 of file operators.cpp.

## operator+() [20/64]

ITPP_EXPORT cmat operator+ | ( | const imat & | a,
|  | const cmat & | b
| ) |  |

Addition operator for imat and cmat.

Definition at line 457 of file operators.cpp.

## operator+() [21/64]

ITPP_EXPORT cmat operator+ | ( | const mat & | a,
|  | const cmat & | b
| ) |  |

Addition operator for mat and cmat.

Definition at line 470 of file operators.cpp.

## operator+() [22/64]

std::complex< double > itpp::operator+ | ( | const int & | x,
|  | const std::complex< double > & | y
| ) |  |

inline

Addition operator for int and complex double.

Definition at line 43 of file operators.h.

## operator+() [23/64]

std::complex< double > itpp::operator+ | ( | const float & | x,
|  | const std::complex< double > & | y
| ) |  |

inline

Addition operator for float and complex double.

Definition at line 45 of file operators.h.

## operator+() [24/64]

std::complex< double > itpp::operator+ | ( | const std::complex< double > & | x,
|  | const int & | y
| ) |  |

inline

Addition operator for int and complex double.

Definition at line 47 of file operators.h.

## operator+() [25/64]

std::complex< double > itpp::operator+ | ( | const std::complex< double > & | x,
|  | const float & | y
| ) |  |

inline

Addition operator for float and complex double.

Definition at line 49 of file operators.h.

## operator-() [9/63]

std::complex< double > itpp::operator- | ( | const int & | x,
|  | const std::complex< double > & | y
| ) |  |

inline

Subtraction operator for int and complex double.

Definition at line 52 of file operators.h.

## operator-() [10/63]

std::complex< double > itpp::operator- | ( | const float & | x,
|  | const std::complex< double > & | y
| ) |  |

inline

Subtraction operator for float and complex double.

Definition at line 54 of file operators.h.

## operator-() [11/63]

std::complex< double > itpp::operator- | ( | const std::complex< double > & | x,
|  | const int & | y
| ) |  |

inline

Subtraction operator for int and complex double.

Definition at line 56 of file operators.h.

## operator-() [12/63]

std::complex< double > itpp::operator- | ( | const std::complex< double > & | x,
|  | const float & | y
| ) |  |

inline

Subtraction operator for float and complex double.

Definition at line 58 of file operators.h.

## operator*() [20/72]

std::complex< double > itpp::operator* | ( | const int & | x,
|  | const std::complex< double > & | y
| ) |  |

inline

Multiplication operator for int and complex double.

Definition at line 61 of file operators.h.

## operator*() [21/72]

std::complex< double > itpp::operator* | ( | const float & | x,
|  | const std::complex< double > & | y
| ) |  |

inline

Multiplication operator for float and complex double.

Definition at line 63 of file operators.h.

## operator*() [22/72]

std::complex< double > itpp::operator* | ( | const std::complex< double > & | x,
|  | const int & | y
| ) |  |

inline

Multiplication operator for int and complex double.

Definition at line 65 of file operators.h.

## operator*() [23/72]

std::complex< double > itpp::operator* | ( | const std::complex< double > & | x,
|  | const float & | y
| ) |  |

inline

Multiplication operator for float and complex double.

Definition at line 67 of file operators.h.

## operator/() [10/23]

std::complex< double > itpp::operator/ | ( | const std::complex< double > & | x,
|  | const int & | y
| ) |  |

inline

Division operator for complex double and int.

Definition at line 70 of file operators.h.

## operator/() [11/23]

std::complex< double > itpp::operator/ | ( | const std::complex< double > & | x,
|  | const float & | y
| ) |  |

inline

Division operator for complex double and float.

Definition at line 72 of file operators.h.

## operator+() [26/64]

vec operator+ | ( | const float & | s,
|  | const vec & | v
| ) |  |

inline

Addition operator for float and vec.

Definition at line 81 of file operators.h.

## operator+() [27/64]

vec operator+ | ( | const short & | s,
|  | const vec & | v
| ) |  |

inline

Addition operator for short and vec.

Definition at line 87 of file operators.h.

## operator+() [28/64]

vec operator+ | ( | const int & | s,
|  | const vec & | v
| ) |  |

inline

Addition operator for int and vec.

Definition at line 93 of file operators.h.

## operator+() [29/64]

vec operator+ | ( | const vec & | v,
|  | const float & | s
| ) |  |

inline

Addition operator for vec and float.

Definition at line 99 of file operators.h.

## operator+() [30/64]

vec operator+ | ( | const vec & | v,
|  | const short & | s
| ) |  |

inline

Addition operator for vec and short.

Definition at line 105 of file operators.h.

## operator+() [31/64]

vec operator+ | ( | const vec & | v,
|  | const int & | s
| ) |  |

inline

Addition operator for vec and int.

Definition at line 111 of file operators.h.

## operator-() [13/63]

vec operator- | ( | const float & | s,
|  | const vec & | v
| ) |  |

inline

Subtraction operator for float and vec.

Definition at line 117 of file operators.h.

## operator-() [14/63]

vec operator- | ( | const short & | s,
|  | const vec & | v
| ) |  |

inline

Subtraction operator for short and vec.

Definition at line 123 of file operators.h.

## operator-() [15/63]

vec operator- | ( | const int & | s,
|  | const vec & | v
| ) |  |

inline

Subtraction operator for int and vec.

Definition at line 129 of file operators.h.

## operator-() [16/63]

vec operator- | ( | const vec & | v,
|  | const float & | s
| ) |  |

inline

Subtraction operator for vec and float.

Definition at line 135 of file operators.h.

## operator-() [17/63]

vec operator- | ( | const vec & | v,
|  | const short & | s
| ) |  |

inline

Subtraction operator for vec and short.

Definition at line 141 of file operators.h.

## operator-() [18/63]

vec operator- | ( | const vec & | v,
|  | const int & | s
| ) |  |

inline

Subtraction operator for vec and int.

Definition at line 147 of file operators.h.

## operator*() [24/72]

vec operator* | ( | const float & | s,
|  | const vec & | v
| ) |  |

inline

Multiplication operator for float and vec.

Definition at line 153 of file operators.h.

## operator*() [25/72]

vec operator* | ( | const short & | s,
|  | const vec & | v
| ) |  |

inline

Multiplication operator for short and vec.

Definition at line 159 of file operators.h.

## operator*() [26/72]

vec operator* | ( | const int & | s,
|  | const vec & | v
| ) |  |

inline

Multiplication operator for int and vec.

Definition at line 165 of file operators.h.

## operator*() [27/72]

vec operator* | ( | const vec & | v,
|  | const float & | s
| ) |  |

inline

Multiplication operator for vec and float.

Definition at line 177 of file operators.h.

## operator*() [28/72]

vec operator* | ( | const vec & | v,
|  | const short & | s
| ) |  |

inline

Multiplication operator for vec and short.

Definition at line 183 of file operators.h.

## operator*() [29/72]

vec operator* | ( | const vec & | v,
|  | const int & | s
| ) |  |

inline

Multiplication operator for vec and int.

Definition at line 189 of file operators.h.

## operator/() [12/23]

vec operator/ | ( | const vec & | v,
|  | const float & | s
| ) |  |

inline

Division operator for vec and float.

Definition at line 201 of file operators.h.

## operator/() [13/23]

vec operator/ | ( | const vec & | v,
|  | const short & | s
| ) |  |

inline

Division operator for vec and short.

Definition at line 207 of file operators.h.

## operator/() [14/23]

vec operator/ | ( | const vec & | v,
|  | const int & | s
| ) |  |

inline

Division operator for vec and int.

Definition at line 213 of file operators.h.

## operator+() [32/64]

vec operator+ | ( | const ivec & | v,
|  | const double & | s
| ) |  |

inline

Addition operator for ivec and double.

Definition at line 228 of file operators.h.

## operator-() [19/63]

vec operator- | ( | const ivec & | v,
|  | const double & | s
| ) |  |

inline

Subtraction operator for ivec and double.

Definition at line 240 of file operators.h.

## operator*() [30/72]

vec operator* | ( | const ivec & | v,
|  | const double & | s
| ) |  |

inline

Multiplication operator for ivec and double.

Definition at line 252 of file operators.h.

## operator+() [33/64]

cvec operator+ | ( | const ivec & | v,
|  | const std::complex< double > & | s
| ) |  |

inline

Addition operator for ivec and complex<double>

Definition at line 276 of file operators.h.

## operator-() [20/63]

cvec operator- | ( | const ivec & | v,
|  | const std::complex< double > & | s
| ) |  |

inline

Subtraction operator for ivec and complex<double>

Definition at line 288 of file operators.h.

## operator*() [31/72]

cvec operator* | ( | const ivec & | v,
|  | const std::complex< double > & | s
| ) |  |

inline

Multiplication operator for ivec and complex<double>

Definition at line 300 of file operators.h.

## operator+() [34/64]

cvec operator+ | ( | const float & | s,
|  | const cvec & | v
| ) |  |

inline

Addition operator for float and cvec.

Definition at line 326 of file operators.h.

## operator+() [35/64]

cvec operator+ | ( | const short & | s,
|  | const cvec & | v
| ) |  |

inline

Addition operator for short and cvec.

Definition at line 332 of file operators.h.

## operator+() [36/64]

cvec operator+ | ( | const int & | s,
|  | const cvec & | v
| ) |  |

inline

Addition operator for int and cvec.

Definition at line 338 of file operators.h.

## operator+() [37/64]

cvec operator+ | ( | const cvec & | v,
|  | const float & | s
| ) |  |

inline

Addition operator for cvec and float.

Definition at line 344 of file operators.h.

## operator+() [38/64]

cvec operator+ | ( | const cvec & | v,
|  | const double & | s
| ) |  |

inline

Addition operator for cvec and double.

Definition at line 350 of file operators.h.

## operator+() [39/64]

cvec operator+ | ( | const cvec & | v,
|  | const short & | s
| ) |  |

inline

Addition operator for cvec and short.

Definition at line 356 of file operators.h.

## operator+() [40/64]

cvec operator+ | ( | const cvec & | v,
|  | const int & | s
| ) |  |

inline

Addition operator for cvec and int.

Definition at line 362 of file operators.h.

## operator-() [21/63]

cvec operator- | ( | const float & | s,
|  | const cvec & | v
| ) |  |

inline

Subtraction operator for float and cvec.

Definition at line 374 of file operators.h.

## operator-() [22/63]

cvec operator- | ( | const short & | s,
|  | const cvec & | v
| ) |  |

inline

Subtraction operator for short and cvec.

Definition at line 380 of file operators.h.

## operator-() [23/63]

cvec operator- | ( | const int & | s,
|  | const cvec & | v
| ) |  |

inline

Subtraction operator for int and cvec.

Definition at line 386 of file operators.h.

## operator-() [24/63]

cvec operator- | ( | const cvec & | v,
|  | const float & | s
| ) |  |

inline

Subtraction operator for cvec and float.

Definition at line 392 of file operators.h.

## operator-() [25/63]

cvec operator- | ( | const cvec & | v,
|  | const double & | s
| ) |  |

inline

Subtraction operator for cvec and double.

Definition at line 398 of file operators.h.

## operator-() [26/63]

cvec operator- | ( | const cvec & | v,
|  | const short & | s
| ) |  |

inline

Subtraction operator for cvec and short.

Definition at line 404 of file operators.h.

## operator-() [27/63]

cvec operator- | ( | const cvec & | v,
|  | const int & | s
| ) |  |

inline

Subtraction operator for cvec and int.

Definition at line 410 of file operators.h.

## operator*() [32/72]

cvec operator* | ( | const float & | s,
|  | const cvec & | v
| ) |  |

inline

Multiplication operator for float and cvec.

Definition at line 422 of file operators.h.

## operator*() [33/72]

cvec operator* | ( | const short & | s,
|  | const cvec & | v
| ) |  |

inline

Multiplication operator for short and cvec.

Definition at line 428 of file operators.h.

## operator*() [34/72]

cvec operator* | ( | const int & | s,
|  | const cvec & | v
| ) |  |

inline

Multiplication operator for int and cvec.

Definition at line 434 of file operators.h.

## operator*() [35/72]

cvec operator* | ( | const cvec & | v,
|  | const float & | s
| ) |  |

inline

Multiplication operator for cvec and float.

Definition at line 440 of file operators.h.

## operator*() [36/72]

cvec operator* | ( | const cvec & | v,
|  | const double & | s
| ) |  |

inline

Multiplication operator for cvec and double.

Definition at line 446 of file operators.h.

## operator*() [37/72]

cvec operator* | ( | const cvec & | v,
|  | const short & | s
| ) |  |

inline

Multiplication operator for cvec and short.

Definition at line 452 of file operators.h.

## operator*() [38/72]

cvec operator* | ( | const cvec & | v,
|  | const int & | s
| ) |  |

inline

Multiplication operator for cvec and int.

Definition at line 458 of file operators.h.

## operator/() [15/23]

cvec operator/ | ( | const cvec & | v,
|  | const float & | s
| ) |  |

inline

Division operator for cvec and float.

Definition at line 476 of file operators.h.

## operator/() [16/23]

cvec operator/ | ( | const cvec & | v,
|  | const short & | s
| ) |  |

inline

Division operator for cvec and short.

Definition at line 482 of file operators.h.

## operator/() [17/23]

cvec operator/ | ( | const cvec & | v,
|  | const int & | s
| ) |  |

inline

Division operator for cvec and int.

Definition at line 488 of file operators.h.

## operator+() [41/64]

mat operator+ | ( | const float & | s,
|  | const mat & | m
| ) |  |

inline

Addition operator for float and mat.

Definition at line 496 of file operators.h.

## operator+() [42/64]

mat operator+ | ( | const short & | s,
|  | const mat & | m
| ) |  |

inline

Addition operator for short and mat.

Definition at line 502 of file operators.h.

## operator+() [43/64]

mat operator+ | ( | const int & | s,
|  | const mat & | m
| ) |  |

inline

Addition operator for int and mat.

Definition at line 508 of file operators.h.

## operator+() [44/64]

mat operator+ | ( | const mat & | m,
|  | const float & | s
| ) |  |

inline

Addition operator for mat and float.

Definition at line 514 of file operators.h.

## operator+() [45/64]

mat operator+ | ( | const mat & | m,
|  | const short & | s
| ) |  |

inline

Addition operator for mat and short.

Definition at line 520 of file operators.h.

## operator+() [46/64]

mat operator+ | ( | const mat & | m,
|  | const int & | s
| ) |  |

inline

Addition operator for mat and int.

Definition at line 526 of file operators.h.

## operator-() [28/63]

mat operator- | ( | const float & | s,
|  | const mat & | m
| ) |  |

inline

Subtraction operator for float and mat.

Definition at line 532 of file operators.h.

## operator-() [29/63]

mat operator- | ( | const short & | s,
|  | const mat & | m
| ) |  |

inline

Subtraction operator for short and mat.

Definition at line 538 of file operators.h.

## operator-() [30/63]

mat operator- | ( | const int & | s,
|  | const mat & | m
| ) |  |

inline

Subtraction operator for int and mat.

Definition at line 544 of file operators.h.

## operator-() [31/63]

mat operator- | ( | const mat & | m,
|  | const float & | s
| ) |  |

inline

Subtraction operator for mat and float.

Definition at line 550 of file operators.h.

## operator-() [32/63]

mat operator- | ( | const mat & | m,
|  | const short & | s
| ) |  |

inline

Subtraction operator for mat and short.

Definition at line 556 of file operators.h.

## operator-() [33/63]

mat operator- | ( | const mat & | m,
|  | const int & | s
| ) |  |

inline

Subtraction operator for mat and int.

Definition at line 562 of file operators.h.

## operator*() [39/72]

mat operator* | ( | const float & | s,
|  | const mat & | m
| ) |  |

inline

Multiplication operator for float and mat.

Definition at line 568 of file operators.h.

## operator*() [40/72]

mat operator* | ( | const short & | s,
|  | const mat & | m
| ) |  |

inline

Multiplication operator for short and mat.

Definition at line 574 of file operators.h.

## operator*() [41/72]

mat operator* | ( | const int & | s,
|  | const mat & | m
| ) |  |

inline

Multiplication operator for int and mat.

Definition at line 580 of file operators.h.

## operator*() [42/72]

mat operator* | ( | const mat & | m,
|  | const float & | s
| ) |  |

inline

Multiplication operator for mat and float.

Definition at line 586 of file operators.h.

## operator*() [43/72]

mat operator* | ( | const mat & | m,
|  | const short & | s
| ) |  |

inline

Multiplication operator for mat and short.

Definition at line 592 of file operators.h.

## operator*() [44/72]

mat operator* | ( | const mat & | m,
|  | const int & | s
| ) |  |

inline

Multiplication operator for mat and int.

Definition at line 598 of file operators.h.

## operator/() [18/23]

mat operator/ | ( | const mat & | m,
|  | const float & | s
| ) |  |

inline

Division operator for mat and float.

Definition at line 604 of file operators.h.

## operator/() [19/23]

mat operator/ | ( | const mat & | m,
|  | const short & | s
| ) |  |

inline

Division operator for mat and short.

Definition at line 610 of file operators.h.

## operator/() [20/23]

mat operator/ | ( | const mat & | m,
|  | const int & | s
| ) |  |

inline

Division operator for mat and int.

Definition at line 616 of file operators.h.

## operator*() [45/72]

cmat operator* | ( | const mat & | m,
|  | const std::complex< double > & | s
| ) |  |

inline

Multiplication operator for mat and complex<double>

Definition at line 648 of file operators.h.

## operator+() [47/64]

vec operator+ | ( | const vec & | a,
|  | const bvec & | b
| ) |  |

inline

Addition operator for vec and bvec.

Definition at line 680 of file operators.h.

## operator+() [48/64]

vec operator+ | ( | const vec & | a,
|  | const svec & | b
| ) |  |

inline

Addition operator for vec and svec.

Definition at line 686 of file operators.h.

## operator+() [49/64]

vec operator+ | ( | const vec & | a,
|  | const ivec & | b
| ) |  |

inline

Addition operator for vec and ivec.

Definition at line 692 of file operators.h.

## operator-() [34/63]

vec operator- | ( | const bvec & | a,
|  | const vec & | b
| ) |  |

inline

Subtraction operator for bvec and vec.

Definition at line 698 of file operators.h.

## operator-() [35/63]

vec operator- | ( | const svec & | a,
|  | const vec & | b
| ) |  |

inline

Subtraction operator for svec and vec.

Definition at line 704 of file operators.h.

## operator-() [36/63]

vec operator- | ( | const ivec & | a,
|  | const vec & | b
| ) |  |

inline

Subtraction operator for ivec and vec.

Definition at line 710 of file operators.h.

## operator-() [37/63]

vec operator- | ( | const vec & | a,
|  | const bvec & | b
| ) |  |

inline

Subtraction operator for vec and bvec.

Definition at line 716 of file operators.h.

## operator-() [38/63]

vec operator- | ( | const vec & | a,
|  | const svec & | b
| ) |  |

inline

Subtraction operator for vec and svec.

Definition at line 722 of file operators.h.

## operator-() [39/63]

vec operator- | ( | const vec & | a,
|  | const ivec & | b
| ) |  |

inline

Subtraction operator for vec and ivec.

Definition at line 728 of file operators.h.

## operator*() [46/72]

double operator* | ( | const vec & | a,
|  | const bvec & | b
| ) |  |

inline

Multiplication operator for vec and bvec.

Definition at line 752 of file operators.h.

## operator*() [47/72]

double operator* | ( | const vec & | a,
|  | const svec & | b
| ) |  |

inline

Multiplication operator for vec and svec.

Definition at line 758 of file operators.h.

## operator*() [48/72]

double operator* | ( | const vec & | a,
|  | const ivec & | b
| ) |  |

inline

Multiplication operator for vec and ivec.

Definition at line 764 of file operators.h.

## operator+() [50/64]

cvec operator+ | ( | const cvec & | a,
|  | const bvec & | b
| ) |  |

inline

Addition operator for cvec and bvec.

Definition at line 790 of file operators.h.

## operator+() [51/64]

cvec operator+ | ( | const cvec & | a,
|  | const svec & | b
| ) |  |

inline

Addition operator for cvec and svec.

Definition at line 796 of file operators.h.

## operator+() [52/64]

cvec operator+ | ( | const cvec & | a,
|  | const ivec & | b
| ) |  |

inline

Addition operator for cvec and ivec.

Definition at line 802 of file operators.h.

## operator-() [40/63]

cvec operator- | ( | const bvec & | a,
|  | const cvec & | b
| ) |  |

inline

Subtraction operator for bvec and cvec.

Definition at line 808 of file operators.h.

## operator-() [41/63]

cvec operator- | ( | const svec & | a,
|  | const cvec & | b
| ) |  |

inline

Subtraction operator for svec and cvec.

Definition at line 814 of file operators.h.

## operator-() [42/63]

cvec operator- | ( | const ivec & | a,
|  | const cvec & | b
| ) |  |

inline

Subtraction operator for ivec and cvec.

Definition at line 820 of file operators.h.

## operator-() [43/63]

cvec operator- | ( | const cvec & | a,
|  | const bvec & | b
| ) |  |

inline

Subtraction operator for cvec and bvec.

Definition at line 826 of file operators.h.

## operator-() [44/63]

cvec operator- | ( | const cvec & | a,
|  | const svec & | b
| ) |  |

inline

Subtraction operator for cvec and svec.

Definition at line 832 of file operators.h.

## operator-() [45/63]

cvec operator- | ( | const cvec & | a,
|  | const ivec & | b
| ) |  |

inline

Subtraction operator for cvec and ivec.

Definition at line 838 of file operators.h.

## operator*() [49/72]

std::complex< double > operator* | ( | const cvec & | a,
|  | const bvec & | b
| ) |  |

inline

Multiplication operator for cvec and bvec.

Definition at line 862 of file operators.h.

## operator*() [50/72]

std::complex< double > operator* | ( | const cvec & | a,
|  | const svec & | b
| ) |  |

inline

Multiplication operator for cvec and svec.

Definition at line 868 of file operators.h.

## operator*() [51/72]

std::complex< double > operator* | ( | const cvec & | a,
|  | const ivec & | b
| ) |  |

inline

Multiplication operator for cvec and ivec.

Definition at line 874 of file operators.h.

## operator+() [53/64]

mat operator+ | ( | const mat & | a,
|  | const bmat & | b
| ) |  |

inline

Addition operator for mat and bmat.

Definition at line 900 of file operators.h.

## operator+() [54/64]

mat operator+ | ( | const mat & | a,
|  | const smat & | b
| ) |  |

inline

Addition operator for mat and smat.

Definition at line 906 of file operators.h.

## operator+() [55/64]

mat operator+ | ( | const mat & | a,
|  | const imat & | b
| ) |  |

inline

Addition operator for mat and imat.

Definition at line 912 of file operators.h.

## operator-() [46/63]

mat operator- | ( | const bmat & | a,
|  | const mat & | b
| ) |  |

inline

Subtraction operator for bmat and mat.

Definition at line 918 of file operators.h.

## operator-() [47/63]

mat operator- | ( | const smat & | a,
|  | const mat & | b
| ) |  |

inline

Subtraction operator for smat and mat.

Definition at line 924 of file operators.h.

## operator-() [48/63]

mat operator- | ( | const imat & | a,
|  | const mat & | b
| ) |  |

inline

Subtraction operator for imat and mat.

Definition at line 930 of file operators.h.

## operator-() [49/63]

mat operator- | ( | const mat & | a,
|  | const bmat & | b
| ) |  |

inline

Subtraction operator for mat and bmat.

Definition at line 936 of file operators.h.

## operator-() [50/63]

mat operator- | ( | const mat & | a,
|  | const smat & | b
| ) |  |

inline

Subtraction operator for mat and smat.

Definition at line 942 of file operators.h.

## operator-() [51/63]

mat operator- | ( | const mat & | a,
|  | const imat & | b
| ) |  |

inline

Subtraction operator for mat and imat.

Definition at line 948 of file operators.h.

## operator+() [56/64]

cmat operator+ | ( | const cmat & | a,
|  | const bmat & | b
| ) |  |

inline

Addition operator for cmat and bmat.

Definition at line 980 of file operators.h.

## operator+() [57/64]

cmat operator+ | ( | const cmat & | a,
|  | const smat & | b
| ) |  |

inline

Addition operator for cmat and smat.

Definition at line 986 of file operators.h.

## operator+() [58/64]

cmat operator+ | ( | const cmat & | a,
|  | const imat & | b
| ) |  |

inline

Addition operator for cmat and imat.

Definition at line 992 of file operators.h.

## operator+() [59/64]

cmat operator+ | ( | const cmat & | a,
|  | const mat & | b
| ) |  |

inline

Addition operator for cmat and mat.

Definition at line 998 of file operators.h.

## operator-() [52/63]

cmat operator- | ( | const bmat & | a,
|  | const cmat & | b
| ) |  |

inline

Subtraction operator for bmat and cmat.

Definition at line 1004 of file operators.h.

## operator-() [53/63]

cmat operator- | ( | const smat & | a,
|  | const cmat & | b
| ) |  |

inline

Subtraction operator for smat and cmat.

Definition at line 1010 of file operators.h.

## operator-() [54/63]

cmat operator- | ( | const imat & | a,
|  | const cmat & | b
| ) |  |

inline

Subtraction operator for imat and cmat.

Definition at line 1016 of file operators.h.

## operator-() [55/63]

cmat operator- | ( | const mat & | a,
|  | const cmat & | b
| ) |  |

inline

Subtraction operator for mat and cmat.

Definition at line 1022 of file operators.h.

## operator-() [56/63]

cmat operator- | ( | const cmat & | a,
|  | const bmat & | b
| ) |  |

inline

Subtraction operator for cmat and bmat.

Definition at line 1028 of file operators.h.

## operator-() [57/63]

cmat operator- | ( | const cmat & | a,
|  | const smat & | b
| ) |  |

inline

Subtraction operator for cmat and smat.

Definition at line 1034 of file operators.h.

## operator-() [58/63]

cmat operator- | ( | const cmat & | a,
|  | const imat & | b
| ) |  |

inline

Subtraction operator for cmat and imat.

Definition at line 1040 of file operators.h.

## operator-() [59/63]

cmat operator- | ( | const cmat & | a,
|  | const mat & | b
| ) |  |

inline

Subtraction operator for cmat and mat.

Definition at line 1046 of file operators.h.

## operator*() [52/72]

cmat operator* | ( | const mat & | a,
|  | const cmat & | b
| ) |  |

inline

Multiplication operator for mat and cmat.

Definition at line 1052 of file operators.h.

## operator*() [53/72]

cmat operator* | ( | const bmat & | a,
|  | const cmat & | b
| ) |  |

inline

Multiplication operator for bmat and cmat.

Definition at line 1058 of file operators.h.

## operator*() [54/72]

cmat operator* | ( | const smat & | a,
|  | const cmat & | b
| ) |  |

inline

Multiplication operator for smat and cmat.

Definition at line 1064 of file operators.h.

## operator*() [55/72]

cmat operator* | ( | const imat & | a,
|  | const cmat & | b
| ) |  |

inline

Multiplication operator for imat and cmat.

Definition at line 1070 of file operators.h.

## operator*() [56/72]

cmat operator* | ( | const cmat & | a,
|  | const mat & | b
| ) |  |

inline

Multiplication operator for cmat and mat.

Definition at line 1076 of file operators.h.

## operator*() [57/72]

cmat operator* | ( | const cmat & | a,
|  | const bmat & | b
| ) |  |

inline

Multiplication operator for cmat and bmat.

Definition at line 1082 of file operators.h.

## operator*() [58/72]

cmat operator* | ( | const cmat & | a,
|  | const smat & | b
| ) |  |

inline

Multiplication operator for cmat and smat.

Definition at line 1088 of file operators.h.

## operator*() [59/72]

cmat operator* | ( | const cmat & | a,
|  | const imat & | b
| ) |  |

inline

Multiplication operator for cmat and imat.

Definition at line 1094 of file operators.h.

## global_seed_provider()

GlobalSeedProvider & itpp::global_seed_provider | ( |  | ) |

Definition at line 169 of file random.cpp.

## operator+() [60/64]

template<class T >

Sparse_Mat< T > itpp::operator+ | ( | const Sparse_Mat< T > & | m1,
|  | const Sparse_Mat< T > & | m2
| ) |  |

m1+m2 where m1 and m2 are sparse matrices

Addition m1+m2 where m1 and m2 are sparse matrices.

Definition at line 760 of file smat.h.

## operator*() [60/72]

template<class T >

Sparse_Mat< T > itpp::operator* | ( | const T & | c,
|  | const Sparse_Mat< T > & | m
| ) |  |

c*m where c is a scalar and m is a sparse matrix

Multiplication c*m where c is a scalar and m is a sparse matrix.

Definition at line 774 of file smat.h.

## operator*() [61/72]

template<class T >

Sparse_Mat< T > itpp::operator* | ( | const Sparse_Mat< T > & | m1,
|  | const Sparse_Mat< T > & | m2
| ) |  |

m1*m2 where m1 and m2 are sparse matrices

Multiplication m1*m2 where m1 and m2 are sparse matrices.

Definition at line 789 of file smat.h.

## operator*() [62/72]

template<class T >

Sparse_Vec< T > itpp::operator* | ( | const Sparse_Mat< T > & | m,
|  | const Sparse_Vec< T > & | v
| ) |  |

m*v where m is a sparse matrix and v is a sparse vector

Multiplication m*v where m is a sparse matrix and v is a sparse vector.

Definition at line 860 of file smat.h.

## operator*() [63/72]

template<class T >

Vec< T > itpp::operator* | ( | const Sparse_Mat< T > & | m,
|  | const Vec< T > & | v
| ) |  |

m*v where m is a sparse matrix and v is a full column vector

Multiplication m*v where m is a sparse matrix and v is a full column vector.

Definition at line 886 of file smat.h.

## operator*() [64/72]

template<class T >

Vec< T > itpp::operator* | ( | const Vec< T > & | v,
|  | const Sparse_Mat< T > & | m
| ) |  |

v'*m where m is a sparse matrix and v is a full column vector

Multiplication v'*m where m is a sparse matrix and v is a full column vector.

Definition at line 902 of file smat.h.

## trans_mult() [1/3]

template<class T >

Mat< T > itpp::trans_mult | ( | const Sparse_Mat< T > & | m | ) |

m'*m where m is a sparse matrix

Multiplication m'*m where m is a sparse matrix. Returns a full, dense matrix.

Definition at line 916 of file smat.h.

## trans_mult_s()

template<class T >

Sparse_Mat< T > itpp::trans_mult_s | ( | const Sparse_Mat< T > & | m | ) |

m'*m where m is a sparse matrix

Multiplication m'*m where m is a sparse matrix, Returns a sparse matrix.

Definition at line 934 of file smat.h.

## trans_mult() [2/3]

template<class T >

Sparse_Mat< T > itpp::trans_mult | ( | const Sparse_Mat< T > & | m1,
|  | const Sparse_Mat< T > & | m2
| ) |  |

m1'*m2 where m1 and m2 are sparse matrices

Multiplication m1'*m2 where m1 and m2 are sparse matrices.

Definition at line 957 of file smat.h.

## trans_mult() [3/3]

template<class T >

Vec< T > itpp::trans_mult | ( | const Sparse_Mat< T > & | m,
|  | const Vec< T > & | v
| ) |  |

m'*v where m is a sparse matrix and v is a full column vector

Multiplication m'*v where m is a sparse matrix and v is a full column vector.

Definition at line 973 of file smat.h.

## mult_trans() [2/2]

template<class T >

Sparse_Mat< T > itpp::mult_trans | ( | const Sparse_Mat< T > & | m1,
|  | const Sparse_Mat< T > & | m2
| ) |  |

m1*m2' where m1 and m2 are sparse matrices

Multiplication m1*m2' where m1 and m2 are sparse matrices.

Definition at line 983 of file smat.h.

## sparse() [1/3]

template<class T >

Sparse_Mat< T > itpp::sparse | ( | const Mat< T > & | m,
|  | T | epsilon
| ) |  |

inline

Convert a dense matrix `m` into its sparse representation.

Definition at line 990 of file smat.h.

## full() [1/2]

template<class T >

Mat< T > itpp::full | ( | const Sparse_Mat< T > & | s | ) |

inline

Convert a sparse matrix `s` into its dense representation.

Definition at line 998 of file smat.h.

Referenced by itpp::Sparse_Mat< T >::full(), itpp::Sparse_Vec< T >::full(), itpp::MOG_generic::get_diag_covs(), itpp::MOG_generic::get_full_covs(), getSamples(), and itpp::MOG_generic::is_full().

## transpose()

template<class T >

Sparse_Mat< T > itpp::transpose | ( | const Sparse_Mat< T > & | s | ) |

inline

Transpose a sparse matrix `s`.

Definition at line 1007 of file smat.h.

## operator+() [61/64]

template<class T >

Sparse_Vec< T > itpp::operator+ | ( | const Sparse_Vec< T > & | v1,
|  | const Sparse_Vec< T > & | v2
| ) |  |

v1+v2 where v1 and v2 are sparse vector

Addition v1+v2 where v1 and v2 are sparse vector.

Definition at line 1171 of file svec.h.

## operator*() [65/72]

template<class T >

T itpp::operator* | ( | const Sparse_Vec< T > & | v1,
|  | const Sparse_Vec< T > & | v2
| ) |  |

v1*v2 where v1 and v2 are sparse vectors

Scalar product v1*v2 where v1 and v2 are sparse vectors.

Definition at line 1041 of file svec.h.

## operator*() [66/72]

template<class T >

T itpp::operator* | ( | const Sparse_Vec< T > & | v1,
|  | const Vec< T > & | v2
| ) |  |

v1*v2 where v1 is a sparse vector and v2 is a dense vector

Scalar product v1*v2 where v1 is a sparse vector and v2 is a dense vector.

Definition at line 1057 of file svec.h.

## operator*() [67/72]

template<class T >

T itpp::operator* | ( | const Vec< T > & | v1,
|  | const Sparse_Vec< T > & | v2
| ) |  |

v1*v2 where v1 is a dense vector and v2 is a sparse vector

Scalar product v1*v2 where v1 is a dense vector and v2 is a sparse vector.

Definition at line 1069 of file svec.h.

## elem_mult() [2/7]

template<class T >

Sparse_Vec< T > itpp::elem_mult | ( | const Sparse_Vec< T > & | v1,
|  | const Sparse_Vec< T > & | v2
| ) |  |

Elementwise multiplication of two sparse vectors returning a sparse vector.

Element wise multiplication of two sparse vectors.

Definition at line 1081 of file svec.h.

## elem_mult() [3/7]

template<class T >

Vec< T > itpp::elem_mult | ( | const Sparse_Vec< T > & | v1,
|  | const Vec< T > & | v2
| ) |  |

Elementwise multiplication of a sparse vector and a dense vector returning a dense vector.

Element wise multiplication of a sparse vector and a dense vector.

Definition at line 1105 of file svec.h.

## elem_mult_s() [1/2]

template<class T >

Sparse_Vec< T > itpp::elem_mult_s | ( | const Sparse_Vec< T > & | v1,
|  | const Vec< T > & | v2
| ) |  |

Elementwise multiplication of a sparse vector and a dense vector returning a sparse vector.

Element wise multiplication of a sparse vector and a dense vector returning a sparse vector.

Definition at line 1118 of file svec.h.

## elem_mult() [4/7]

template<class T >

Vec< T > itpp::elem_mult | ( | const Vec< T > & | v1,
|  | const Sparse_Vec< T > & | v2
| ) |  |

Elementwise multiplication of a dense vector and a sparse vector returning a dense vector.

Element wise multiplication of a a dense vector and a sparse vector.

Definition at line 1138 of file svec.h.

## elem_mult_s() [2/2]

template<class T >

Sparse_Vec< T > itpp::elem_mult_s | ( | const Vec< T > & | v1,
|  | const Sparse_Vec< T > & | v2
| ) |  |

Elementwise multiplication of a dense vector and a sparse vector returning a sparse vector.

Element wise multiplication of a a dense vector and a sparse vector returning a sparse vector.

Definition at line 1151 of file svec.h.

## sparse() [2/3]

template<class T >

Sparse_Vec< T > itpp::sparse | ( | const Vec< T > & | v | ) |

inline

Convert a dense vector `v` into its sparse representation.

Definition at line 1199 of file svec.h.

## sparse() [3/3]

template<class T >

Sparse_Vec< T > itpp::sparse | ( | const Vec< T > & | v,
|  | T | epsilon
| ) |  |

inline

Convert a dense vector `v` into its sparse representation.

Definition at line 1207 of file svec.h.

## full() [2/2]

template<class T >

Vec< T > itpp::full | ( | const Sparse_Vec< T > & | s | ) |

inline

Convert a sparse vector `s` into its dense representation.

Definition at line 1215 of file svec.h.

## operator+() [62/64]

template<class Num_T >

Vec< Num_T > itpp::operator+ | ( | const Vec< Num_T > & | v1,
|  | const Vec< Num_T > & | v2
| ) |  |

Addition of two vectors.

Definition at line 880 of file vec.h.

## operator+() [63/64]

template<class Num_T >

Vec< Num_T > itpp::operator+ | ( | const Vec< Num_T > & | v,
|  | Num_T | t
| ) |  |

Addition of a vector and a scalar.

Definition at line 893 of file vec.h.

## operator+() [64/64]

template<class Num_T >

Vec< Num_T > itpp::operator+ | ( | Num_T | t,
|  | const Vec< Num_T > & | v
| ) |  |

Addition of a scalar and a vector.

Definition at line 905 of file vec.h.

## operator-() [60/63]

template<class Num_T >

Vec< Num_T > itpp::operator- | ( | const Vec< Num_T > & | v1,
|  | const Vec< Num_T > & | v2
| ) |  |

Subtraction of a vector from a vector.

Subtraction of `v2` from `v1`.

Definition at line 943 of file vec.h.

## operator-() [61/63]

template<class Num_T >

Vec< Num_T > itpp::operator- | ( | const Vec< Num_T > & | v,
|  | Num_T | t
| ) |  |

Subtraction of a scalar from a vector.

Subtraction of scalar from vector.

Definition at line 956 of file vec.h.

## operator-() [62/63]

template<class Num_T >

Vec< Num_T > itpp::operator- | ( | Num_T | t,
|  | const Vec< Num_T > & | v
| ) |  |

Subtraction of vector from scalar. Results in a vector.

Subtraction of vector from scalar.

Definition at line 968 of file vec.h.

## operator-() [63/63]

template<class Num_T >

Vec< Num_T > itpp::operator- | ( | const Vec< Num_T > & | v | ) |

Negation of vector.

Definition at line 980 of file vec.h.

## dot()

template<class Num_T >

Num_T itpp::dot | ( | const Vec< Num_T > & | v1,
|  | const Vec< Num_T > & | v2
| ) |  |

Inner (dot) product of two vectors v1 and v2.

Definition at line 1005 of file vec.h.

References it_assert_debug, and itpp::Array< T >::length().

Referenced by fpica(), operator*(), itpp::Newton_Search::search(), and itpp::Line_Search::search().

## operator*() [68/72]

template<class Num_T >

Num_T itpp::operator* | ( | const Vec< Num_T > & | v1,
|  | const Vec< Num_T > & | v2
| ) |  |

inline

Inner (dot) product of two vectors v1 and v2.

Definition at line 999 of file vec.h.

References dot().

## outer_product()

template<class Num_T >

Mat< Num_T > itpp::outer_product | ( | const Vec< Num_T > & | v1,
|  | const Vec< Num_T > & | v2,
|  | bool | hermitian = `false`
| ) |  |

Outer product of two vectors v1 and v2.

When v1 and v2 are complex vectors (cvec), the third boolean argument hermitian can be set to true to conjugate v2 (Matlab's v1 * v2' operation). This parameter is ignored for types other then cvec.

Definition at line 1021 of file vec.h.

References it_assert_debug, and itpp::Array< T >::length().

Referenced by itpp::Newton_Search::search().

## operator*() [69/72]

template<class Num_T >

Vec< Num_T > itpp::operator* | ( | const Vec< Num_T > & | v,
|  | Num_T | t
| ) |  |

Multiplication of a vector and a scalar.

Elementwise multiplication of vector and scalar.

Definition at line 1044 of file vec.h.

## operator*() [70/72]

template<class Num_T >

Vec< Num_T > itpp::operator* | ( | Num_T | t,
|  | const Vec< Num_T > & | v
| ) |  |

inline

Multiplication of a scalar and a vector. Results in a vector.

Elementwise multiplication of vector and scalar.

Definition at line 1055 of file vec.h.

## elem_mult() [5/7]

template<class Num_T >

Vec< Num_T > itpp::elem_mult | ( | const Vec< Num_T > & | a,
|  | const Vec< Num_T > & | b
| ) |  |

inline

Element-wise multiplication of two vectors.

Elementwise multiplication.

Definition at line 1061 of file vec.h.

## elem_mult() [6/7]

template<class Num_T >

Vec< Num_T > itpp::elem_mult | ( | const Vec< Num_T > & | a,
|  | const Vec< Num_T > & | b,
|  | const Vec< Num_T > & | c
| ) |  |

inline

Element-wise multiplication of three vectors.

Elementwise multiplication of three vectors.

Definition at line 1069 of file vec.h.

## elem_mult() [7/7]

template<class Num_T >

Vec< Num_T > itpp::elem_mult | ( | const Vec< Num_T > & | a,
|  | const Vec< Num_T > & | b,
|  | const Vec< Num_T > & | c,
|  | const Vec< Num_T > & | d
| ) |  |

inline

Element-wise multiplication of four vectors.

Elementwise multiplication of four vectors.

Definition at line 1078 of file vec.h.

## elem_mult_out() [4/6]

template<class Num_T >

void itpp::elem_mult_out | ( | const Vec< Num_T > & | a,
|  | const Vec< Num_T > & | b,
|  | Vec< Num_T > & | out
| ) |  |

Element-wise multiplication of two vectors, storing the result in vector `out`.

Elementwise multiplication, storing the result in vector `out`.

Definition at line 1087 of file vec.h.

## elem_mult_out() [5/6]

template<class Num_T >

void itpp::elem_mult_out | ( | const Vec< Num_T > & | a,
|  | const Vec< Num_T > & | b,
|  | const Vec< Num_T > & | c,
|  | Vec< Num_T > & | out
| ) |  |

Element-wise multiplication of three vectors, storing the result in vector `out`.

Elementwise multiplication of three vectors, storing the result in vector `out`.

Definition at line 1097 of file vec.h.

## elem_mult_out() [6/6]

template<class Num_T >

void itpp::elem_mult_out | ( | const Vec< Num_T > & | a,
|  | const Vec< Num_T > & | b,
|  | const Vec< Num_T > & | c,
|  | const Vec< Num_T > & | d,
|  | Vec< Num_T > & | out
| ) |  |

Element-wise multiplication of four vectors, storing the result in vector `out`.

Elementwise multiplication of four vectors, storing the result in vector `out`.

Definition at line 1108 of file vec.h.

## elem_mult_inplace() [2/2]

template<class Num_T >

void itpp::elem_mult_inplace | ( | const Vec< Num_T > & | a,
|  | Vec< Num_T > & | b
| ) |  |

inline

In-place element-wise multiplication of two vectors. Faster version of b = elem_mult(a,b).

In-place element-wise multiplication of two vectors. Fast version of b = elem_mult(a,b).

Definition at line 1123 of file vec.h.

## elem_mult_sum() [2/2]

template<class Num_T >

Num_T itpp::elem_mult_sum | ( | const Vec< Num_T > & | a,
|  | const Vec< Num_T > & | b
| ) |  |

inline

Element-wise multiplication of two vectors, followed by summation of the resultant elements. Fast version of sum(elem_mult(a,b)).

Element-wise multiplication of two vectors, followed by summation of the resultant elements. Fast version of sum(elem_mult(a,b))

Definition at line 1132 of file vec.h.

## operator/() [21/23]

template<class Num_T >

Vec< Num_T > itpp::operator/ | ( | const Vec< Num_T > & | v,
|  | Num_T | t
| ) |  |

Division of all elements in `v` with `t`.

Elementwise division.

Definition at line 1143 of file vec.h.

## operator/() [22/23]

template<class Num_T >

Vec< Num_T > itpp::operator/ | ( | Num_T | t,
|  | const Vec< Num_T > & | v
| ) |  |

Division of `t` with all elements in `v`.

Elementwise division.

Definition at line 1155 of file vec.h.

## elem_div() [2/3]

template<class Num_T >

Vec< Num_T > itpp::elem_div | ( | const Vec< Num_T > & | a,
|  | const Vec< Num_T > & | b
| ) |  |

inline

Elementwise division of two vectors.

Elementwise division.

Definition at line 1196 of file vec.h.

## elem_div() [3/3]

template<class Num_T >

Vec< Num_T > itpp::elem_div | ( | Num_T | t,
|  | const Vec< Num_T > & | v
| ) |  |

This function is deprecated. Please use operator/(Num_T, const Vec<Num_T &) instead.

This function is deprecated. Please use operator/(Num_T, const Vec<Num_T> &) instead.

Definition at line 1167 of file vec.h.

## elem_div_out() [2/2]

template<class Num_T >

void itpp::elem_div_out | ( | const Vec< Num_T > & | a,
|  | const Vec< Num_T > & | b,
|  | Vec< Num_T > & | out
| ) |  |

Elementwise division of two vectors, storing the result in vector `out`.

Elementwise division.

Definition at line 1204 of file vec.h.

## elem_div_sum() [2/2]

template<class Num_T >

Num_T itpp::elem_div_sum | ( | const Vec< Num_T > & | a,
|  | const Vec< Num_T > & | b
| ) |  |

inline

Elementwise division of two vectors, followed by summation of the resultant elements. Fast version of sum(elem_div(a,b))

Elementwise division, followed by summation of the resultant elements. Fast version of sum(elem_mult(a,b))

Definition at line 1215 of file vec.h.

## concat() [5/10]

template<class Num_T >

Vec< Num_T > itpp::concat | ( | const Vec< Num_T > & | v,
|  | Num_T | a
| ) |  |

Append element `a` to the end of the vector `v`.

Append element `t` to the end of the vector `v`.

Definition at line 1324 of file vec.h.

## concat() [6/10]

template<class Num_T >

Vec< Num_T > itpp::concat | ( | Num_T | a,
|  | const Vec< Num_T > & | v
| ) |  |

Concat element `a` to the beginning of the vector `v`.

Insert element `t` at the beginning of the vector `v`.

Definition at line 1334 of file vec.h.

## concat() [7/10]

template<class Num_T >

Vec< Num_T > itpp::concat | ( | const Vec< Num_T > & | v1,
|  | const Vec< Num_T > & | v2
| ) |  |

Concat vectors `v1` and `v2`.

Concatenate vectors `v1` and `v2`.

Definition at line 1344 of file vec.h.

## concat() [8/10]

template<class Num_T >

Vec< Num_T > itpp::concat | ( | const Vec< Num_T > & | v1,
|  | const Vec< Num_T > & | v2,
|  | const Vec< Num_T > & | v3
| ) |  |

Concat vectors `v1`, `v2` and `v3`.

Concatenate vectors `v1`, `v2` and `v3`.

Definition at line 1355 of file vec.h.

## concat() [9/10]

template<class Num_T >

Vec< Num_T > itpp::concat | ( | const Vec< Num_T > & | v1,
|  | const Vec< Num_T > & | v2,
|  | const Vec< Num_T > & | v3,
|  | const Vec< Num_T > & | v4
| ) |  |

Concat vectors `v1`, `v2`, `v3` and `v4`.

Concatenate vectors `v1`, `v2`, `v3` and `v4`.

Definition at line 1369 of file vec.h.

## concat() [10/10]

template<class Num_T >

Vec< Num_T > itpp::concat | ( | const Vec< Num_T > & | v1,
|  | const Vec< Num_T > & | v2,
|  | const Vec< Num_T > & | v3,
|  | const Vec< Num_T > & | v4,
|  | const Vec< Num_T > & | v5
| ) |  |

Concat vectors `v1`, `v2` `v3`, `v4` and `v5`.

Concatenate vectors `v1`, `v2`, `v3`, `v4` and `v5`.

Definition at line 1385 of file vec.h.

## cerfc_continued_fraction()

std::complex< double > itpp::cerfc_continued_fraction | ( | const std::complex< double > & | z | ) |

Abramowitz and Stegun: Eq. (7.1.14) gives this continued fraction for erfc(z)

erfc(z) = sqrt(pi).exp(-z^2). 1 1/2 1 3/2 2 5/2 — — — — — — ... z + z + z + z + z + z +

This is evaluated using Lentz's method, as described in the narative of Numerical Recipes in C.

The continued fraction is true providing real(z) > 0. In practice we like real(z) to be significantly greater than 0, say greater than 0.5.

Definition at line 52 of file error.cpp.

References abs(), eps, exp(), and pi.

Referenced by cerf_continued_fraction().

## cerf_continued_fraction()

std::complex< double > itpp::cerf_continued_fraction | ( | const std::complex< double > & | z | ) |

Complementary function to `cerfc_continued_fraction`.

Definition at line 88 of file error.cpp.

References cerfc_continued_fraction().

Referenced by erf().

## cerf_series()

std::complex< double > itpp::cerf_series | ( | const std::complex< double > & | z | ) |

Abramawitz and Stegun: Eq. (7.1.5) gives a series for erf(z) good for all z, but converges faster for smallish abs(z), say abs(z) < 2.

Definition at line 100 of file error.cpp.

References abs(), pi, and sum().

Referenced by erf().

## cerf_rybicki()

std::complex< double > itpp::cerf_rybicki | ( | const std::complex< double > & | z | ) |

Numerical Recipes quotes a formula due to Rybicki for evaluating Dawson's Integral:

exp(-x^2) integral exp(t^2).dt = 1/sqrt(pi) lim sum exp(-(z-n.h)^2) / n 0 to x h->0 n odd

This can be adapted to erf(z).

Definition at line 124 of file error.cpp.

References exp(), pi, and sum().

Referenced by erf().

## quad() [1/2]

template<typename Ftn >

double itpp::quad | ( | Ftn | f,
|  | double | a,
|  | double | b,
|  | double | tol = `std::numeric_limits<double>::epsilon()`
| ) |  |

1-dimensional numerical Simpson quadrature integration

Calculate the 1-dimensional integral

Uses an adaptive Simpson quadrature method. See [Gander] for more details. The integrand is specified as a templated function object.

Example:

#include "itpp/itbase.h"
struct Integrand_Functor
{
double operator()(const double x) const
{
return x*log(x);
}
};
int main()
{
double res = quad(Integrand_Functor(), 1.5, 3.5);
cout << "res = " << res << endl;
return 0;
}
itpp::Array
General array class.
Definition array.h:105
itpp::Array::operator()
T & operator()(int i)
Get the i element.
Definition array.h:290
itpp::log
vec log(const vec &x)
The natural logarithm of the elements.
Definition log_exp.h:241
itbase.h
Include file for the IT++ base module.
itpp::quad
double quad(Ftn f, double a, double b, double tol=std::numeric_limits< double >::epsilon())
Definition integration.h:162

References:

[Gander] Gander, W. and W. Gautschi, "Adaptive Quadrature - Revisited", BIT, Vol. 40, 2000, pp. 84-101. This document is also available at http://www.inf.ethz.ch/personal/gander.

Definition at line 162 of file integration.h.

References sum().

Referenced by itpp::EXIT::apriori_mutual_info().

## quad() [2/2]

ITPP_EXPORT double itpp::quad | ( | double(*)(double) | f,
|  | double | a,
|  | double | b,
|  | double | tol = `std::numeric_limits< double >::epsilon()`
| ) |  |

1-dimensional numerical Simpson quadrature integration

Calculate the 1-dimensional integral

Uses an adaptive Simpson quadrature method. See [Gander] for more details. The integrand is specified as a function:

double f(double)

Example:

#include "itpp/itbase.h"
double f(const double x)
{
return x*log(x);
}
int main()
{
double res = quad( f, 1.5, 3.5);
cout << "res = " << res << endl;
return 0;
}

References:

[Gander] Gander, W. and W. Gautschi, "Adaptive Quadrature - Revisited", BIT, Vol. 40, 2000, pp. 84-101. This document is also available at http://www.inf.ethz.ch/personal/gander.

## quadl() [1/2]

template<typename Ftn >

double itpp::quadl | ( | Ftn | f,
|  | double | a,
|  | double | b,
|  | double | tol = `std::numeric_limits<double>::epsilon()`
| ) |  |

1-dimensional numerical adaptive Lobatto quadrature integration

Calculate the 1-dimensional integral

Uses an adaptive Lobatto quadrature method. See [Gander] for more details. The integrand is specified as a templated function object.

Example:

#include "itpp/itbase.h"
struct Integrand_Functor
{
double operator()(const double x) const
{
return x*log(x);
}
};
int main()
{
double res = quadl(Integrand_Functor(), 1.5, 3.5);
cout << "res = " << res << endl;
return 0;
}
itpp::quadl
double quadl(Ftn f, double a, double b, double tol=std::numeric_limits< double >::epsilon())
Definition integration.h:264

References:

[Gander] Gander, W. and W. Gautschi, "Adaptive Quadrature - Revisited", BIT, Vol. 40, 2000, pp. 84-101. This document is also available at http:// www.inf.ethz.ch/personal/gander.

Definition at line 264 of file integration.h.

References sign().

## quadl() [2/2]

ITPP_EXPORT double itpp::quadl | ( | double(*)(double) | f,
|  | double | a,
|  | double | b,
|  | double | tol = `std::numeric_limits< double >::epsilon()`
| ) |  |

1-dimensional numerical adaptive Lobatto quadrature integration

Calculate the 1-dimensional integral

Uses an adaptive Lobatto quadrature method. See [Gander] for more details. The integrand is specified as a function:

double f(double)

Example:

#include "itpp/itbase.h"
double f(const double x)
{
return x*log(x);
}
int main()
{
double res = quadl( f, 1.5, 3.5);
cout << "res = " << res << endl;
return 0;
}

References:

[Gander] Gander, W. and W. Gautschi, "Adaptive Quadrature - Revisited", BIT, Vol. 40, 2000, pp. 84-101. This document is also available at http:// www.inf.ethz.ch/personal/gander.

## reverse_int()

int itpp::reverse_int | ( | int | length,
|  | int | in
| ) |  |

related

Reverses the bitrepresentation of in (of size length) and converts to an integer

Definition at line 1442 of file convcode.cpp.

Referenced by itpp::Rec_Syst_Conv_Code::set_generator_polynomials().

## weight_int()

int itpp::weight_int | ( | int | length,
|  | int | in
| ) |  |

related

Calculate the Hamming weight of the binary representation of in of size length

Definition at line 1460 of file convcode.cpp.

## compare_spectra() [1/2]

int itpp::compare_spectra | ( | ivec | v1,
|  | ivec | v2
| ) |  |

related

Compare two distance spectra. Return 1 if v1 is less, 0 if v2 less, and -1 if equal.

Definition at line 1472 of file convcode.cpp.

## compare_spectra() [2/2]

int itpp::compare_spectra | ( | ivec | v1,
|  | ivec | v2,
|  | vec | weight_profile
| ) |  |

related

Compare two distance spectra using a weight profile.

Return 1 if v1 is less, 0 if v2 less, and -1 if equal.

Definition at line 1492 of file convcode.cpp.

## operator>>() [3/4]

std::istream & itpp::operator>> | ( | std::istream & | is,
|  | GF & | ingf
| ) |  |

Input stream operator for GF.

Input stream for GF(q)

Definition at line 93 of file galois.cpp.

## operator<<() [4/10]

std::ostream & itpp::operator<< | ( | std::ostream & | os,
|  | const GF & | ingf
| ) |  |

Output stream operator for GF.

Output stream for GF(q)

Definition at line 125 of file galois.cpp.

## operator<<() [5/10]

ITPP_EXPORT std::ostream & itpp::operator<< | ( | std::ostream & | os,
|  | const GFX & | ingfx
| ) |  |

Output stream operator for GFX.

Output stream.

Definition at line 135 of file galois.cpp.

## divgfx()

GFX itpp::divgfx | ( | const GFX & | c,
|  | const GFX & | g
| ) |  |

related

Division of two GFX (local help function)

Definition at line 157 of file galois.cpp.

Referenced by itpp::BCH::decode(), and itpp::Reed_Solomon::decode().

## modgfx()

GFX itpp::modgfx | ( | const GFX & | a,
|  | const GFX & | b
| ) |  |

related

Modulo function of two GFX (local help function)

Definition at line 183 of file galois.cpp.

Referenced by itpp::BCH::encode(), and itpp::Reed_Solomon::encode().

## operator*() [71/72]

GFX itpp::operator* | ( | const GF & | ingf,
|  | const GFX & | ingfx
| ) |  |

inline

Multiplication of GF and GFX.

Multiply a GF element with a GF(q)[x].

Definition at line 543 of file galois.h.

## operator*() [72/72]

GFX itpp::operator* | ( | const GFX & | ingfx,
|  | const GF & | ingf
| ) |  |

inline

Multiplication of GFX and GF.

Multiply a GF(q)[x] with a GF element.

Definition at line 552 of file galois.h.

## operator/() [23/23]

GFX itpp::operator/ | ( | const GFX & | ingfx,
|  | const GF & | ingf
| ) |  |

inline

Division of GFX by GF.

Divide a GF(q)[x] with a GF element.

Definition at line 557 of file galois.h.

## operator<<() [6/10]

ITPP_EXPORT std::ostream & operator<< | ( | std::ostream & | os,
|  | const LDPC_Code & | C
| ) |  |

Print some properties of the LDPC codec in plain text.

Print some properties of the codec in plain text.

Definition at line 1791 of file ldpc.cpp.

## operator<<() [7/10]

ITPP_EXPORT std::ostream & operator<< | ( | std::ostream & | os,
|  | const LLR_calc_unit & | lcu
| ) |  |

Print some properties of the LLR calculation unit in plain text.

Definition at line 162 of file llr.cpp.

## operator<<() [8/10]

ITPP_EXPORT std::ostream & operator<< | ( | std::ostream & | os,
|  | const Modulator_NRD & | mod
| ) |  |

Print some properties of the MIMO modulator (mainly to aid debugging)

Output some properties of the MIMO modulator (mainly to aid debugging)

Definition at line 679 of file modulator_nd.cpp.

## operator<<() [9/10]

ITPP_EXPORT std::ostream & operator<< | ( | std::ostream & | os,
|  | const Modulator_NCD & | mod
| ) |  |

Print some properties of the MIMO modulator (mainly to aid debugging)

Definition at line 923 of file modulator_nd.cpp.

## formal_derivate()

GFX itpp::formal_derivate | ( | const GFX & | f | ) |

Local help function.

Definition at line 39 of file reedsolomon.cpp.

References itpp::GFX::get_size(), and itpp::GFX::get_true_degree().

Referenced by itpp::Reed_Solomon::decode().

## calculate_uncoded_size()

int itpp::calculate_uncoded_size | ( | Punctured_Turbo_Codec & | tc,
|  | int | punctured_size,
|  | int & | fill_bits
| ) |  |

Calculates length of the turbo code input block required to produce output block of length punctured_size. Some puncturing patterns might not allow to create block with such a length and then fill_bits of dummy bits must be used.

Parameters

  tc | Instance of Punctured_Turbo_Codec
  punctured_size | Required size of punctured encoded block
  fill_bits | Number of dummy bits that must be attached to the encoded block (parameter calculated within the function)

Definition at line 874 of file turbo.cpp.

## wcdma_turbo_interleaver_sequence()

ITPP_EXPORT ivec wcdma_turbo_interleaver_sequence | ( | int | interleaver_size | ) |

Generates the interleaver sequence for the internal turbo encoder interleaver used in WCDMA.

Definition at line 933 of file turbo.cpp.

## lte_turbo_interleaver_sequence()

ITPP_EXPORT ivec lte_turbo_interleaver_sequence | ( | int | interleaver_size | ) |

Generates the interleaver sequence for the internal turbo encoder interleaver used in LTE.

Author
  qdelfin and Stephan Ludwig

Definition at line 1135 of file turbo.cpp.

## fminunc()

ITPP_EXPORT vec itpp::fminunc | ( | double(*)(const vec &) | function,
|  | vec(*)(const vec &) | gradient,
|  | const vec & | x0
| ) |  |

Unconstrained minimization.

Unconstrained minimization using a Newton or Quasi-Newton optimization method that try to minimize the objective function given an initial guess .

The function and the gradient need to be known and supplied.

The default algorithm is a Quasi-Newton search using BFGS updates of the inverse Hessian matrix.

Definition at line 692 of file newton_search.cpp.

## min()

const Sequence_Number & itpp::min | ( | const Sequence_Number & | n1,
|  | const Sequence_Number & | n2
| ) |  |

inline

ADD DOCUMENTATION HERE.

Definition at line 125 of file tcp.h.

## max()

const Sequence_Number & itpp::max | ( | const Sequence_Number & | n1,
|  | const Sequence_Number & | n2
| ) |  |

inline

ADD DOCUMENTATION HERE.

Definition at line 127 of file tcp.h.

## bitrv()

template<class T >

void itpp::bitrv | ( | Vec< T > & | out | ) |

Bit reverse.

Definition at line 252 of file transforms.h.

References itpp::Array< T >::size().

Referenced by dwht(), and self_dwht().

## is_valid()

bool itpp::is_valid | ( | const Audio_Stream_Description & | d | ) |

inline

validity check for stream description d

Definition at line 102 of file audiofile.h.

References encoded_sample_size(), itpp::Audio_Stream_Description::get_encoding(), and itpp::Audio_Stream_Description::get_num_channels().

## operator<<() [10/10]

template<typename Binary_Out_Stream >

Binary_Out_Stream & itpp::operator<< | ( | Binary_Out_Stream & | s,
|  | Sample_24 | v
| ) |  |

insertion operator for 24-bit PCM sample

Definition at line 174 of file audiosample.h.

## operator>>() [4/4]

template<typename Binary_In_Stream >

Binary_In_Stream & itpp::operator>> | ( | Binary_In_Stream & | s,
|  | Sample_24 & | v
| ) |  |

extraction operator for 24-bit PCM sample

Definition at line 191 of file audiosample.h.

## encoded_sample_size()

std::size_t itpp::encoded_sample_size | ( | Audio_Encoding | e | ) |

inline

Size of encoded sample based on the encoding type e.

Definition at line 302 of file audiosample.h.

Referenced by is_valid().

## scalar_quantize() [1/2]

double itpp::scalar_quantize | ( | double | x,
|  | vec & | Levels
| ) |  |

inline

ADD DOCUMENTATION HERE.

Definition at line 201 of file vq.h.

References scalar_encode().

## scalar_quantize() [2/2]

vec itpp::scalar_quantize | ( | vec & | x,
|  | vec & | Levels
| ) |  |

inline

ADD DOCUMENTATION HERE.

Definition at line 203 of file vq.h.

References scalar_encode().

## MOG_diag_MAP()

void itpp::MOG_diag_MAP | ( | MOG_diag & | model_in,
|  | MOG_diag & | prior_model_in,
|  | Array< vec > & | X_in,
|  | int | max_iter_in = `10`,
|  | double | alpha_in = `0.5`,
|  | double | var_floor_in = `0.0`,
|  | double | weight_floor_in = `0.0`,
|  | bool | verbose_in = `false`
| ) |  |

NOT YET IMPLEMENTED. Maximum a Posteriori (MAP) Expectation Maximisation optimiser for Mixtures of Gaussians.

Parameters

  model_in | The model to optimise (MOG_diag)
  prior_model_in | The model representing the prior
  X_in | The training data (array of vectors)
  max_iter_in | Maximum number of iterations
  alpha_in | Coefficient for combining the parameters with the prior. 0 <= _alpha <= 1.
  var_floor_in | Variance floor (lowest allowable variance). Set to 0.0 to use the default.
  weight_floor_in | Weight floor (lowest allowable weight). Set to 0.0 to use the default.
  verbose_in | ADD DOCUMENTATION HERE

Note
  NOT YET IMPLEMENTED.
  The variance and weight floors are set to std::numeric_limits<double>::min() if they are below that value. The largest allowable weight floor is 1/K, where K is the number of Gaussians.

Definition at line 322 of file mog_diag_em.cpp.

References it_error.

## Variable Documentation

## DEFAULT_FACTORY

const Factory itpp::DEFAULT_FACTORY

Default (dummy) factory.

Definition at line 139 of file factory.h.

## __tic_toc_timer

Real_Timer itpp::__tic_toc_timer

Global object for tic and toc functions.

Definition at line 75 of file timing.cpp.

Referenced by tic(), toc(), and toc_print().

## pi

const double itpp::pi = 3.14159265358979323846

Constant Pi.

Definition at line 103 of file misc.h.

Referenced by arma_estimator(), blackman(), cerf_rybicki(), cerf_series(), cerfc_continued_fraction(), chebwin(), deg_to_rad(), itpp::PSK::demodulate_bits(), itpp::QPSK::demodulate_soft_bits(), itpp::QPSK::demodulate_soft_bits(), freqz(), freqz(), itpp::IFFT_Fading_Generator::generate_Jakes(), hamming(), hann(), hanning(), itpp::Impulse_Source::Impulse_Source(), itpp::Rice_Fading_Generator::init_MEDS(), rad_to_deg(), itpp::Sawtooth_Source::Sawtooth_Source(), itpp::ND_UPSK::set_M(), itpp::Raised_Cosine< T1 >::set_pulse_shape(), itpp::Root_Raised_Cosine< T1 >::set_pulse_shape(), sinc(), itpp::Sine_Source::Sine_Source(), itpp::Square_Source::Square_Source(), and itpp::Triangle_Source::Triangle_Source().

## m_2pi

const double itpp::m_2pi = 2 * pi

Constant 2*Pi.

Definition at line 106 of file misc.h.

Referenced by itpp::Correlated_Fading_Generator::add_LOS(), itpp::PSK::demodulate_bits(), itpp::Rice_Fading_Generator::generate(), itpp::FIR_Fading_Generator::Jakes_filter(), itpp::PSK::set_M(), itpp::MOG_generic::setup_covs(), and itpp::MOG_diag_EM_sup::update_internals().

## eps

const double itpp::eps = std::numeric_limits<double>::epsilon()

Constant eps.

Definition at line 109 of file misc.h.

Referenced by cerfc_continued_fraction(), itpp::Sparse_Vec< T >::get_subvector(), itpp::Sparse_Vec< T >::operator/=(), itpp::Sparse_Vec< T >::operator=(), itpp::Sparse_Vec< T >::operator=(), orth(), rank(), itpp::Sparse_Vec< T >::remove_small_elements(), itpp::Newton_Search::search(), itpp::Line_Search::search(), itpp::Sparse_Vec< T >::set(), itpp::Sparse_Vec< T >::set_new(), itpp::Sparse_Vec< T >::set_new(), itpp::Sparse_Vec< T >::set_small_element(), itpp::Sparse_Vec< T >::Sparse_Vec(), and itpp::Sparse_Vec< T >::Sparse_Vec().

## Block_Interleaver< double >

template class ITPP_EXPORT itpp::Block_Interleaver< double >

Definition at line 39 of file interleave.cpp.

## Block_Interleaver< short >

template class ITPP_EXPORT itpp::Block_Interleaver< short >

Definition at line 40 of file interleave.cpp.

## Block_Interleaver< int >

template class ITPP_EXPORT itpp::Block_Interleaver< int >

Definition at line 41 of file interleave.cpp.

## Block_Interleaver< bin >

template class ITPP_EXPORT itpp::Block_Interleaver< bin >

Definition at line 43 of file interleave.cpp.

## Cross_Interleaver< double >

template class ITPP_EXPORT itpp::Cross_Interleaver< double >

Definition at line 45 of file interleave.cpp.

## Cross_Interleaver< short >

template class ITPP_EXPORT itpp::Cross_Interleaver< short >

Definition at line 46 of file interleave.cpp.

## Cross_Interleaver< int >

template class ITPP_EXPORT itpp::Cross_Interleaver< int >

Definition at line 47 of file interleave.cpp.

## Cross_Interleaver< bin >

template class ITPP_EXPORT itpp::Cross_Interleaver< bin >

Definition at line 49 of file interleave.cpp.

## Sequence_Interleaver< double >

template class ITPP_EXPORT itpp::Sequence_Interleaver< double >

Definition at line 51 of file interleave.cpp.

## Sequence_Interleaver< short >

template class ITPP_EXPORT itpp::Sequence_Interleaver< short >

Definition at line 52 of file interleave.cpp.

## Sequence_Interleaver< int >

template class ITPP_EXPORT itpp::Sequence_Interleaver< int >

Definition at line 53 of file interleave.cpp.

## Sequence_Interleaver< bin >

template class ITPP_EXPORT itpp::Sequence_Interleaver< bin >

Definition at line 55 of file interleave.cpp.

## LDPC_binary_file_version

const int itpp::LDPC_binary_file_version = 2

static

Version of the binary file with generator and decoder data.

This has to be global since it is used in LDPC_Generator and LDPC_Code classes

Definition at line 42 of file ldpc.cpp.

Referenced by itpp::LDPC_Generator_Systematic::load(), itpp::BLDPC_Generator::load(), itpp::LDPC_Code::load_code(), itpp::LDPC_Generator_Systematic::save(), itpp::BLDPC_Generator::save(), and itpp::LDPC_Code::save_code().

## Pulse_Shape< double, double, double >

template class ITPP_EXPORT itpp::Pulse_Shape< double, double, double >

Definition at line 39 of file pulse_shape.cpp.

## Root_Raised_Cosine< double >

template class ITPP_EXPORT itpp::Root_Raised_Cosine< double >

Definition at line 45 of file pulse_shape.cpp.

## Raised_Cosine< double >

template class ITPP_EXPORT itpp::Raised_Cosine< double >

Definition at line 48 of file pulse_shape.cpp.

## com_log

double(* itpp::com_log) (double, double) | ( | double | ,
|  | double |
| ) |  | = NULL

Pointer to logarithmic branch metric function.

Definition at line 36 of file rec_syst_conv_code.cpp.

Referenced by itpp::Rec_Syst_Conv_Code::log_decode(), and itpp::Rec_Syst_Conv_Code::log_decode_n2().

## CFixed< 64, TC, WRAP >

template class ITPP_EXPORT itpp::CFixed< 64, TC, WRAP >

Definition at line 36 of file cfixed.cpp.

## Fixed< 64, TC, WRAP >

template class ITPP_EXPORT itpp::Fixed< 64, TC, WRAP >

Definition at line 36 of file fixed.cpp.

## MA_Filter< double, double, double >

template class ITPP_EXPORT itpp::MA_Filter< double, double, double >

Definition at line 254 of file filter.cpp.

## AR_Filter< double, double, double >

template class ITPP_EXPORT itpp::AR_Filter< double, double, double >

Definition at line 261 of file filter.cpp.

## ARMA_Filter< double, double, double >

template class ITPP_EXPORT itpp::ARMA_Filter< double, double, double >

Definition at line 269 of file filter.cpp.

Generated on Mon Jun 10 2024 11:49:32 for IT++ by Doxygen 1.9.8