specmat.h

Go to the documentation of this file.

#ifndef SPECMAT_H
#define SPECMAT_H

#include <itpp/base/vec.h>
#include <itpp/base/mat.h>
#include <itpp/base/converters.h>
#include <itpp/itexports.h>

namespace itpp
{

ITPP_EXPORT ivec find(const bvec &invector);




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

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

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

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

ITPP_EXPORT mat eye(int size);
ITPP_EXPORT bmat eye_b(int size);
ITPP_EXPORT imat eye_i(int size);
ITPP_EXPORT cmat eye_c(int size);
template <class T>
void eye(int size, Mat<T> &m)
{
    m.set_size(size, size, false);
    m = T(0);
    for (int i = size - 1; i >= 0; i--)
        m(i, i) = T(1);
}

ITPP_EXPORT vec impulse(int size);

ITPP_EXPORT vec linspace(double from, double to, int length = 100);

template<class T>
Vec<T> linspace_fixed_step(T from, T to, T step = 1)
{
    int points = 0;
    if (0 != step) {
        points = itpp::floor_i(double(to-from)/step)+1;
    }
    if (0 >= points) {
        return Vec<T>(0);
    }

    Vec<T> output(points);
    output(0) = from;
    for (int n = 1; n < points; ++n) {
        output(n) = output(n-1)+step;
    }
    return output;
}

ITPP_EXPORT vec zigzag_space(double t0, double t1, int K = 5);

ITPP_EXPORT imat hadamard(int size);

ITPP_EXPORT imat jacobsthal(int p);

ITPP_EXPORT imat conference(int n);

template <typename Num_T>
const Mat<Num_T> toeplitz(const Vec<Num_T> &c, const Vec<Num_T> &r)
{
    int n_rows = c.size();
    int n_cols = r.size();
    Mat<Num_T> output(n_rows, n_cols);
    for (int i = 0; i < n_rows; ++i) {
        int j_limit = std::min(n_cols, n_rows - i);
        for (int j = 0; j < j_limit; ++j) {
            output(i + j, j) = c(i);
        }
    }
    for (int j = 1; j < n_cols; ++j) {
        int i_limit = std::min(n_rows, n_cols - j);
        for (int i = 0; i < i_limit; ++i) {
            output(i, i + j) = r(j);
        }
    }
    return output;
}

template <typename Num_T>
const Mat<Num_T> toeplitz(const Vec<Num_T> &c)
{
    int s = c.size();
    Mat<Num_T> output(s, s);
    for (int i = 0; i < s; ++i) {
        for (int j = 0; j < s - i; ++j) {
            output(i + j, j) = c(i);
        }
    }
    for (int j = 1; j < s; ++j) {
        for (int i = 0; i < s - j; ++i) {
            output(i, i + j) = c(j);
        }
    }
    return output;
}

ITPP_EXPORT const cmat toeplitz(const cvec &c);




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

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

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

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

ITPP_EXPORT mat givens(double a, double b);

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

ITPP_EXPORT 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 itpp

#endif // #ifndef SPECMAT_H