CUDA Lab Course Reference Manual 2011

/Users/sck/cuda/Praktikum_2011/include/lac/MatrixCreator.h

Go to the documentation of this file.

#ifndef HADAMARD_H
#define HADAMARD_H

#include <iostream>
#include <vector>
#include <lac/full_matrix.h>
#include <lac/FullMatrixAccessor.h>
#include <cmath>

struct MatrixCreator{
    template <typename T>
    static void hadamard(int log2N, ::FullMatrix<T>& H);

    template <typename T>
    static void normalized_hadamard(int log2N, ::FullMatrix<T>& H);

    template <typename T>
            static void extended_hadamard(size_t n_rows, ::FullMatrix<T>& H);

    template <typename T>
            static void extended_normalized_hadamard(size_t n_rows, ::FullMatrix<T>& H);

    template <typename T>
    static void vandermonde_row_wise(::FullMatrix<T>& V,const ::Vector<T>& x){
        vandermonde(V,x,true);
    }

    template <typename T>
    static void vandermonde_col_wise(::FullMatrix<T>& V,const ::Vector<T>& x){
        vandermonde(V,x,false);
    }

    template <typename T>
    static void toepliz(::FullMatrix<T>& M, const ::Vector<T>& r);

private:
    template <typename T>
    static void vandermonde(::FullMatrix<T>& V,const ::Vector<T>& x, bool rowwise = true);
};

template <typename T>
void MatrixCreator::hadamard(int log2N, ::FullMatrix<T>& H){
    int N = std::pow(2.0,log2N);
    H.reinit(N,N);
    H(0,0) = 1;

    for (int n = 1; n < N; n += n) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                H(i+n,j)   =  H(i,j);
                H(i,j+n)   =  H(i,j);
                H(i+n,j+n) = -1 * H(i,j);
            }
        }
    }
}

template <typename T>
        void MatrixCreator::extended_normalized_hadamard(size_t n_rows, ::FullMatrix<T>& H){
        H.reinit(n_rows,n_rows);
        size_t block_size;
        size_t n_rows_rest=n_rows;
        size_t block_begin=0;
        while(true){
            block_size=std::pow(2.,std::floor(log2(n_rows_rest)));
            n_rows_rest-=block_size;

            ::FullMatrix<T> H_tmp(block_size);
            normalized_hadamard(log2(block_size),H_tmp);
            H.fill(H_tmp,block_begin,block_begin,0,0);
            block_begin+=block_size;

            if(n_rows_rest==0)
                break;
        }
    }

template <typename T>
        void MatrixCreator::extended_hadamard(size_t n_rows, ::FullMatrix<T>& H){
        H.reinit(n_rows,n_rows);
        size_t block_size;
        size_t n_rows_rest=n_rows;
        size_t block_begin=0;
        while(true){
            block_size=std::pow(2.,std::floor(log2(n_rows_rest)));
            n_rows_rest-=block_size;

            ::FullMatrix<T> H_tmp(block_size);
            hadamard(log2(block_size),H_tmp);
            H.fill(H_tmp,block_begin,block_begin,0,0);
            block_begin+=block_size;

            if(n_rows_rest==0)
                break;
        }

    }

template <typename T>
void MatrixCreator::normalized_hadamard(int log2N, ::FullMatrix<T>& H)
{
    MatrixCreator::hadamard(log2N, H);

    H /= std::sqrt(H.n_rows() );
}



template <typename T>
void MatrixCreator::vandermonde(::FullMatrix<T>& V,const ::Vector<T>& x, bool rowwise){
    int N = x.size();
    V.reinit(N,N);
    if(rowwise == false){
        for(int i = 0; i<N ; i++){
            for(int j = 0; j<N; j++){
                V(i,j) = pow(x(i),j);
            }
        }
    }
    if(rowwise == true){
        for(int i = 0; i<N ; i++){
            for(int j = 0; j<N; j++){
                V(j,i) = pow(x(i),j);
            }
        }
    }
}

template <typename T>
void MatrixCreator::toepliz(::FullMatrix<T>& M, const ::Vector<T>& r){
    if (r.size()%2 == 0){
        std::cout<<"Toepliz: Nur ungerade Anzahl an Elemente sind Erlaubt"<<std::endl;
    }else{
        int N = (r.size()/2)+1;
        M.reinit(N,N);
        for(int i = 0; i<N; i++){
            for (int j = 0; j<N; j++){
                M(i,j) = r(((N-1)-j)+i);
            }
        }
    }


}

#endif // HADAMARD_H

---