SGSparseMatrix.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) 2012 Fernando José Iglesias García
 * Written (W) 2010,2012 Soeren Sonnenburg
 * Copyright (C) 2010 Berlin Institute of Technology
 * Copyright (C) 2012 Soeren Sonnenburg
 */

#ifndef __SGSPARSEMATRIX_H__
#define __SGSPARSEMATRIX_H__

#include <shogun/lib/config.h>

#include <shogun/lib/common.h>
#include <shogun/lib/SGReferencedData.h>
#include <shogun/lib/SGVector.h>
#include <shogun/io/SGIO.h>

namespace shogun
{

template <class T> class SGSparseVector;
template <class ST> struct SGSparseVectorEntry;
template<class T> class SGMatrix;
class CFile;
class CLibSVMFile;

template <class T> class SGSparseMatrix : public SGReferencedData
{
    public:
        SGSparseMatrix();

        SGSparseMatrix(SGSparseVector<T>* vecs, index_t num_feat,
                index_t num_vec, bool ref_counting=true);

        SGSparseMatrix(index_t num_feat, index_t num_vec, bool ref_counting=true);

        SGSparseMatrix(SGMatrix<T> dense);

        SGSparseMatrix(const SGSparseMatrix &orig);

        virtual ~SGSparseMatrix();

        inline const SGSparseVector<T>& operator[](index_t index) const
        {
            return sparse_matrix[index];
        }

        inline SGSparseVector<T>& operator[](index_t index)
        {
            return sparse_matrix[index];
        }

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

        const SGVector<T> operator*(SGVector<T> v) const
        {
            SGVector<T> result(num_vectors);
            REQUIRE(v.vlen==num_features,
                "Dimension mismatch! %d vs %d\n",
                v.vlen, num_features);
            for (index_t i=0; i<num_vectors; ++i)
                result[i]=sparse_matrix[i].dense_dot(1.0, v.vector, v.vlen, 0.0);

            return result;
        }

        template<class ST> const SGVector<T> operator*(SGVector<ST> v) const;

        inline const T operator()(index_t i_row, index_t i_col) const
        {
            REQUIRE(i_row>=0, "Provided row index %d negative!\n", i_row);
            REQUIRE(i_col>=0, "Provided column index %d negative!\n", i_col);
            REQUIRE(i_row<num_features, "Provided row index (%d) is larger than number of rows (%d)\n",
                            i_row, num_features);
            REQUIRE(i_col<num_vectors, "Provided column index (%d) is larger than number of columns (%d)\n",
                            i_col, num_vectors);

            for (index_t i=0; i<sparse_matrix[i_col].num_feat_entries; ++i)
            {
                if (i_row==sparse_matrix[i_col].features[i].feat_index)
                    return sparse_matrix[i_col].features[i].entry;
            }
            return 0;
        }

        inline T& operator()(index_t i_row, index_t i_col)
        {
            REQUIRE(i_row>=0, "Provided row index %d negative!\n", i_row);
            REQUIRE(i_col>=0, "Provided column index %d negative!\n", i_col);
            REQUIRE(i_row<num_features, "Provided row index (%d) is larger than number of rows (%d)\n",
                            i_row, num_features);
            REQUIRE(i_col<num_vectors, "Provided column index (%d) is larger than number of columns (%d)\n",
                            i_col, num_vectors);

            for (index_t i=0; i<sparse_matrix[i_col].num_feat_entries; ++i)
            {
                if (i_row==sparse_matrix[i_col].features[i].feat_index)
                    return sparse_matrix[i_col].features[i].entry;
            }
            index_t j=sparse_matrix[i_col].num_feat_entries;
            sparse_matrix[i_col].num_feat_entries=j+1;
            sparse_matrix[i_col].features=SG_REALLOC(SGSparseVectorEntry<T>,
                sparse_matrix[i_col].features, j, j+1);
            sparse_matrix[i_col].features[j].feat_index=i_row;
            sparse_matrix[i_col].features[j].entry=static_cast<T>(0);
            return sparse_matrix[i_col].features[j].entry;
        }

        void load(CFile* loader);

        SGVector<float64_t> load_with_labels(CLibSVMFile* libsvm_file, bool do_sort_features=true);

        void save(CFile* saver);

        void save_with_labels(CLibSVMFile* saver, SGVector<float64_t> labels);

        SGSparseMatrix<T> get_transposed();

        void from_dense(SGMatrix<T> full);

        void sort_features();

protected:

        virtual void copy_data(const SGReferencedData& orig);

        virtual void init_data();

        virtual void free_data();

public:

    index_t num_vectors;

    index_t num_features;

    SGSparseVector<T>* sparse_matrix;

};
}
#endif // __SGSPARSEMATRIX_H__