SGMatrix.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2011-2013 Heiko Strathmann
 * Written (W) 2012 Fernando Jose Iglesias Garcia
 * Written (W) 2010,2012 Soeren Sonnenburg
 * Copyright (C) 2010 Berlin Institute of Technology
 * Copyright (C) 2012 Soeren Sonnenburg
 */
#ifndef __SGMATRIX_H__
#define __SGMATRIX_H__

#include <shogun/lib/config.h>
#include <shogun/lib/common.h>
#include <shogun/lib/SGReferencedData.h>

namespace Eigen
{
    template <class, int, int, int, int, int> class Matrix;
    template<int, int> class Stride;
    template <class, int, class> class Map;
}

namespace shogun
{
    template<class T> class SGVector;
    class CFile;

template<class T> class SGMatrix : public SGReferencedData
{
    public:
        typedef Eigen::Matrix<T,-1,-1,0,-1,-1> EigenMatrixXt;
        typedef Eigen::Map<EigenMatrixXt,0,Eigen::Stride<0,0> > EigenMatrixXtMap;

        typedef T Scalar;

        SGMatrix();

        SGMatrix(bool ref_counting);

        SGMatrix(T* m, index_t nrows, index_t ncols, bool ref_counting=true);

        SGMatrix(T* m, index_t nrows, index_t ncols, index_t offset)
            : SGReferencedData(false), matrix(m+offset),
            num_rows(nrows), num_cols(ncols) { }

        SGMatrix(index_t nrows, index_t ncols, bool ref_counting=true);

#ifndef SWIG // SWIG should skip this part
#if defined(HAVE_CXX0X) || defined(HAVE_CXX11)

        template <typename ST> using container_type = SGMatrix<ST>;

#endif // define (HAVE_CXX0X) || defined(HAVE_CXX11)

        SGMatrix(SGVector<T> vec);

        SGMatrix(SGVector<T> vec, index_t nrows, index_t ncols);

        SGMatrix(EigenMatrixXt& mat);

        operator EigenMatrixXtMap() const;
#endif // SWIG

        SGMatrix(const SGMatrix &orig);

        virtual ~SGMatrix();

#ifndef SWIG // SWIG should skip this part

        T* get_column_vector(index_t col) const
        {
            const int64_t c = col;
            return &matrix[c*num_rows];
        }

        SGVector<T> get_row_vector(index_t row) const;

        SGVector<T> get_diagonal_vector() const;

        inline const T& operator()(index_t i_row, index_t i_col) const
        {
            const int64_t c = i_col;
            return matrix[c*num_rows + i_row];
        }

        inline const T& operator[](index_t index) const
        {
            return matrix[index];
        }

        inline T& operator()(index_t i_row, index_t i_col)
        {
            const int64_t c = i_col;
            return matrix[c*num_rows + i_row];
        }

        inline T& operator[](index_t index)
        {
            return matrix[index];
        }

        inline SGMatrix<T> get()
        {
            return *this;
        }

        inline T* data() const
        {
            return matrix;
        }

        inline uint64_t size() const
        {
            const uint64_t c=num_cols;
            return num_rows*c;
        }

        bool operator==(SGMatrix<T>& other);

        bool equals(SGMatrix<T>& other);

        void set_const(T const_elem);

        void zero();

        bool is_symmetric();

        T max_single();

        SGMatrix<T> clone();

        static T* clone_matrix(const T* matrix, int32_t nrows, int32_t ncols);

        static void transpose_matrix(
            T*& matrix, int32_t& num_feat, int32_t& num_vec);

        static void create_diagonal_matrix(T* matrix, T* v,int32_t size);

        static SGMatrix<T> create_identity_matrix(index_t size, T scale);

#ifdef HAVE_LAPACK

        static SGVector<float64_t> compute_eigenvectors(
                SGMatrix<float64_t> matrix);

        static double* compute_eigenvectors(double* matrix, int n, int m);

        void compute_few_eigenvectors(double* matrix_, double*& eigenvalues, double*& eigenvectors,
                                      int n, int il, int iu);
#endif

        static SGMatrix<float64_t> matrix_multiply(
                SGMatrix<float64_t> A, SGMatrix<float64_t> B,
                bool transpose_A=false, bool transpose_B=false,
                float64_t scale=1.0);
#ifdef HAVE_LAPACK

        static void inverse(SGMatrix<float64_t> matrix);

        static float64_t* pinv(
            float64_t* matrix, int32_t rows, int32_t cols,
            float64_t* target=NULL);

#endif

        static float64_t trace(
            float64_t* mat, int32_t cols, int32_t rows);

        static T* get_row_sum(T* matrix, int32_t m, int32_t n);

        static T* get_column_sum(T* matrix, int32_t m, int32_t n);

        void center();

        static void center_matrix(T* matrix, int32_t m, int32_t n);

        void remove_column_mean();

        void display_matrix(const char* name="matrix") const;

        static void display_matrix(
            const T* matrix, int32_t rows, int32_t cols,
            const char* name="matrix", const char* prefix="");

        static void display_matrix(
            const SGMatrix<T> matrix, const char* name="matrix",
            const char* prefix="");

        static SGMatrix<T> get_allocated_matrix(index_t num_rows,
                index_t num_cols, SGMatrix<T> pre_allocated=SGMatrix<T>());

        void load(CFile* loader);

        void save(CFile* saver);
#endif // #ifndef SWIG // SWIG should skip this part

    protected:
        virtual void copy_data(const SGReferencedData &orig);

        virtual void init_data();

        virtual void free_data();

    public:
        T* matrix;
        index_t num_rows;
        index_t num_cols;
};
}
#endif // __SGMATRIX_H__