matfunc.h

Go to the documentation of this file.

/*---------------------------------------------------------------------------*
 *                                   IT++                                    *
 *---------------------------------------------------------------------------*
 * Copyright (c) 1995-2002 by Tony Ottosson, Thomas Eriksson, Pål Frenger,   *
 * Tobias Ringström, and Jonas Samuelsson.                                   *
 *                                                                           *
 * Permission to use, copy, modify, and distribute this software and its     *
 * documentation under the terms of the GNU General Public License is hereby *
 * granted. No representations are made about the suitability of this        *
 * software for any purpose. It is provided "as is" without expressed or     *
 * implied warranty. See the GNU General Public License for more details.    *
 *---------------------------------------------------------------------------*/
//  SPUC - Signal processing using C++ - A DSP library

#ifndef __matfunc_h
#define __matfunc_h

#include "vector.h"
#include "matrix.h"
//#include "converters.h"
//#include "scalfunc.h"
namespace SPUC {
template<class T>
int length(const Vec<T> &v) { return v.length(); }

template<class T>
int size(const Vec<T> &v) { return v.length(); }

template<class T>
T sum(const Vec<T> &v);

template<class T>
T sum_sqr(const Vec<T> &v);

template<class T>
T max(const Vec<T> &v);

template<class T>
T min(const Vec<T> &in);

template<class T>
int max_index(const Vec<T> &in);

template<class T>
int min_index(const Vec<T> &in);

template<class T>
T product(const Vec<T> &v);

template<class T>
Vec<T> cross(const Vec<T> &v1, const Vec<T> &v2);

double mean(const vec &v);

complex<double> mean(const cvec &v);

double mean(const svec &v);

double mean(const ivec &v);

template<class T>
double geometric_mean(const Vec<T> &v);

template<class T>
double median(const Vec<T> &v);

template<class T>
double norm(const Vec<T> &v);

template<>
double norm(const cvec &v);

template<class T>
double norm(const Vec<T> &v, int p);

template<>
double norm(const cvec &v, int p);

template<class T>
double energy(const Vec<T> &v);

/* ACTION: Rewrite for double only ???
template<class T>
dvec normalize(Vec<T> &v1, T radius);
*/

template<class T>
Vec<T> reverse(const Vec<T> &in);

template<class T>
Vec<T> repeat(const Vec<T> &v, int norepeats);

template<class T, class fT>
Vec<T> apply_function(fT (*f)(fT), const Vec<T> &data);

template<class T>
void sort(Vec<T> &data);

template<class T>
ivec sort_index(const Vec<T> &data);

template<class T>
Vec<T> zero_pad(const Vec<T> &v, int n);

template<class T>
Vec<T> zero_pad(const Vec<T> &v);

template<class T>
Mat<T> zero_pad(const Mat<T> &v, int rows, int cols);

//---------- Template functions for Mat<T> ----------------------

template<class T>
T sum(const Mat<T> &m);

template<class T>
T sum_sqr(const Mat<T> &m);

template<class T>
T max(const Mat<T> &m);

template<class T>
T min(const Mat<T> &m);

template<class T>
void max_index(const Mat<T> &in, int &row, int &col);

template<class T>
void min_index(const Mat<T> &in, int &row, int &col);

template<class T>
T product(const Mat<T> &m);

double mean(const mat &m);

complex<double> mean(const cmat &m);

double mean(const smat &m);

double mean(const imat &m);

template<class T>
Mat<T> diag(const Vec<T> &in);

template<class T>
void diag(const Vec<T> &in, Mat<T> &m);

template<class T>
Vec<T> diag(const Mat<T> &in);

// 
template<class T>
Mat<T> bidiag(const Vec<T> &main, const Vec<T> &sup);

template<class T>
void bidiag(const Vec<T> &main, const Vec<T> &sup, Mat<T> &m);

template<class T>
void bidiag(const Mat<T> &in, Vec<T> &main, Vec<T> &sup);

template<class T>
Mat<T> tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub);

template<class T>
void tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub, Mat<T> &m);

template<class T>
void tridiag(const Mat<T> &in, Vec<T> &main, Vec<T> &sup, Vec<T> &sub);

template<class T>
T trace(const Mat<T> &in);

template<class T>
void transpose(const Mat<T> &m, Mat<T> &out);

template<class T>
Mat<T> transpose(const Mat<T> &m);

template<class T>
Mat<T> repeat(const Mat<T> &m, int norepeats);

template<class T, class fT>
Mat<T> apply_function(fT (*f)(fT), const Mat<T> &data);

//-------------------------------------------------------------

template<class T>
Vec<T> rvectorize(const Mat<T> &m);

template<class T>
Vec<T> cvectorize(const Mat<T> &m);

template<class T>
Mat<T> reshape(const Mat<T> &m, int rows, int cols);

template<class T>
Mat<T> reshape(const Vec<T> &m, int rows, int cols);

template<class T> 
void upsample(const Vec<T> &v, int usf, Vec<T> &u);

template<class T>
Vec<T> upsample(const Vec<T> &v, int usf);

template<class T>
void upsample(const Mat<T> &v, int usf, Mat<T> &u);

template<class T>
Mat<T> upsample(const Mat<T> &v, int upsamplefactor);


template<class T>
void lininterp(const Mat<T> &v, int usf, Mat<T> &u);

template<class T>
Mat<T> lininterp(const Mat<T> &v, int usf);

template<class T>
void lininterp(const Vec<T> &v, int usf, Vec<T> &u);

template<class T>
Vec<T> lininterp(const Vec<T> &v, int usf);
} // namespace SPUC {

#endif // __matfunc_h

---