include/lshkit/matrix.h

Go to the documentation of this file.

#ifndef LSHKIT_MATRIX
#define LSHKIT_MATRIX
/* 
    Copyright (C) 2008 Wei Dong <wdong@princeton.edu>. All Rights Reserved.
  
    This file is part of LSHKIT.
  
    LSHKIT 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.

    LSHKIT is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with LSHKIT.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <fstream>
#include <boost/dynamic_bitset.hpp>

namespace lshkit {


template <class T>
class Matrix
{
    int dim, N;
    T *dims;
    T **vecs;

    void load (const char *);
    void save (const char *);

#ifdef MATRIX_MMAP
    int fd;
#endif
public:

    void reset (int _dim, int _N)
    {
        dim = _dim;
        N = _N;
        if (dims != NULL) delete[] dims;
        if (vecs != NULL) delete[] vecs;
        dims = new T[dim * N];
        vecs = new T*[N];
        for (int i = 0; i < N; i++) {
            vecs[i] = dims + i * dim;
        }
    }

    void free (void) {
        dim = N = 0;
        if (dims != NULL) delete[] dims;
        if (vecs != NULL) delete[] dims;
        dims = NULL;
        vecs = NULL;
    }
    

    Matrix () :dim(0), N(0), dims(NULL), vecs(NULL) {}

    Matrix (int _dim, int _N) : dims(NULL), vecs(NULL) { reset(_dim, _N); }

    ~Matrix () { if (dims != NULL) delete[] dims; if (vecs != NULL) delete[] vecs; }

    const T *operator [] (int i) const { return vecs[i]; }

    T *operator [] (int i) { return vecs[i]; }

    T **const getVecs () const {
        return vecs;
    }

    int getDim () const {return dim; }
    int getSize () const {return N; }



    static void peek (const std::string &path, int *elem_size, int *size, int *dim);

    void load (const std::string &path);
    void save (const std::string &path);
    void load (std::istream &is);
    void save (std::ostream &os);

#ifdef MATRIX_MMAP
    void map (const std::string &path);
    void unmap ();
#endif

    Matrix (const std::string &path): dims(NULL),vecs(NULL) { load(path); }

    class Accessor
    {
        const Matrix &matrix_;
        boost::dynamic_bitset<> flags_;
    public:
        typedef unsigned Key;
        typedef const float *Value;

        Accessor(const Matrix &matrix)
            : matrix_(matrix), flags_(matrix.getSize()) {}

        void reset () {
            flags_.reset();
        }

        bool mark (unsigned key) {
            if (flags_[key]) return false;
            flags_.set(key);
            return true;
        }

        const float *operator () (unsigned key) {
            return matrix_[key];
        }
    };

    /*
    class View
    {
        const Matrix<T> *ref_;
        int off_, len_;
    public:
        View (const Matrix<T> *ref, int off, int len)
            : ref_(ref), off_(off), len_(len) {}
        const T *operator [] (int i) const { return ref_->operator[](off_ + i); }
        int getDim () const {return ref_->getDim(); }
        int getSize () const {return len_; }
    };

    View getView (int off, int len) const
    {
        return View(this, off, len);
    }

    View getView () const
    {
        return View(this, 0, getSize());
    }
    */
};

typedef Matrix<float> FloatMatrix;

}

#include <lshkit/matrix-io.h>
#endif

---