specmat.h

Go to the documentation of this file.

/*---------------------------------------------------------------------------*
 *                                   IT++                                    *
 *---------------------------------------------------------------------------*
 * Copyright (c) 1995-2001 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 __specmat_h
#define __specmat_h

#include "vector.h"
#include "matrix.h"
//#include "converters.h"
//#include "scalfunc.h"
namespace SPUC {
ivec find(const bvec &invector);




vec ones(int size);
bvec ones_b(int size);
ivec ones_i(int size);
cvec ones_c(int size);

mat ones(int rows, int cols);
bmat ones_b(int rows, int cols);
imat ones_i(int rows, int cols);
cmat ones_c(int rows, int cols);

vec zeros(int size);
bvec zeros_b(int size);
ivec zeros_i(int size);
cvec zeros_c(int size);

mat zeros(int rows, int cols);
bmat zeros_b(int rows, int cols);
imat zeros_i(int rows, int cols);
cmat zeros_c(int rows, int cols);

mat eye(int size);
bmat eye_b(int size);
imat eye_i(int size);
cmat eye_c(int size);
template <class T>
void eye(int size, Mat<T> &m);

vec impulse(int size);
vec linspace(double from, double to, int length = 100);
imat hadamard(int size);

imat jacobsthal(int p);

imat conference(int n);





vec hamming(int size);
vec hanning(int size);
vec triang(int size);
vec sqrt_win(int size);


mat rotation_matrix(int dim, int plane1, int plane2, double angle);

void house(const vec &x, vec &v, double &beta);

void givens(double a, double b, double &c, double &s);

void givens(double a, double b, mat &m);

mat givens(double a, double b);

void givens_t(double a, double b, mat &m);

mat givens_t(double a, double b);

template <class T>
Vec<T> vec_1(T v0)
{
    Vec<T> v(1);
    v(0) = v0;
    return v;
}

template <class T>
Vec<T> vec_2(T v0, T v1)
{
    Vec<T> v(2);
    v(0) = v0;
    v(1) = v1;
    return v;
}

template <class T>
Vec<T> vec_3(T v0, T v1, T v2)
{
    Vec<T> v(3);
    v(0) = v0;
    v(1) = v1;
    v(2) = v2;
    return v;
}

template <class T>
Mat<T> mat_1x1(T m00)
{
    Mat<T> m(1,1);
    m(0,0) = m00;
    return m;
}

template <class T>
Mat<T> mat_1x2(T m00, T m01)
{
    Mat<T> m(1,2);
    m(0,0) = m00; m(0,1) = m01;
    return m;
}

template <class T>
Mat<T> mat_2x1(T m00,
               T m10)
{
    Mat<T> m(2,1);
    m(0,0) = m00;
    m(1,0) = m10;
    return m;
}

template <class T>
Mat<T> mat_2x2(T m00, T m01,
               T m10, T m11)
{
    Mat<T> m(2,2);
    m(0,0) = m00; m(0,1) = m01;
    m(1,0) = m10; m(1,1) = m11;
    return m;
}

template <class T>
Mat<T> mat_1x3(T m00, T m01, T m02)
{
    Mat<T> m(1,3);
    m(0,0) = m00; m(0,1) = m01; m(0,2) = m02;
    return m;
}

template <class T>
Mat<T> mat_3x1(T m00,
               T m10,
               T m20)
{
    Mat<T> m(3,1);
    m(0,0) = m00;
    m(1,0) = m10;
    m(2,0) = m20;
    return m;
}

template <class T>
Mat<T> mat_2x3(T m00, T m01, T m02,
               T m10, T m11, T m12)
{
    Mat<T> m(2,3);
    m(0,0) = m00; m(0,1) = m01; m(0,2) = m02;
    m(1,0) = m10; m(1,1) = m11; m(1,2) = m12;
    return m;
}

template <class T>
Mat<T> mat_3x2(T m00, T m01,
               T m10, T m11,
               T m20, T m21)
{
    Mat<T> m(3,2);
    m(0,0) = m00; m(0,1) = m01;
    m(1,0) = m10; m(1,1) = m11;
    m(2,0) = m20; m(2,1) = m21;
    return m;
}

template <class T>
Mat<T> mat_3x3(T m00, T m01, T m02,
               T m10, T m11, T m12,
               T m20, T m21, T m22)
{
    Mat<T> m(3,3);
    m(0,0) = m00; m(0,1) = m01; m(0,2) = m02;
    m(1,0) = m10; m(1,1) = m11; m(1,2) = m12;
    m(2,0) = m20; m(2,1) = m21; m(2,2) = m22;
    return m;
}
} // namespace SPUC 

#endif // __specmat_h

---