indexed_vector.hpp

Go to the documentation of this file.

#ifndef FSTINDEXEDVECTOR_H
#define FSTINDEXEDVECTOR_H
 /* 
=========================================================================
Copyright and license:
  * FST4 software (with the exception of any bundled or externally linked
    third-party components) is Copyright (C) 2000-present Institute of
    Information Theory and Automation of the Czech Academy of Sciences (UTIA).
  * FST4 is free software: you can redistribute it and/or modify it under
    the terms of the GNU Affero General Public License as published by the
    Free Software Foundation, version 3. The full text of the license is in
    the file LICENSE in the distribution root and at
    https://www.gnu.org/licenses/agpl-3.0.html.
  * FST4 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 Affero General Public
    License for more details.
  * Closed-source use without the AGPL's copyleft obligations requires a
    commercial license from UTIA; in case of interest write to
    utia@utia.cas.cz. LICENSING.md in the distribution root explains both
    options, the contributor license agreement that every contribution
    requires, and the contacts (technical questions and pull requests:
    somol@utia.cas.cz, with "FST" in the subject line).
========================================================================== */
 
#include <memory>
#include <cassert>
#include <iostream>
#include <limits>
#include <cmath>
#include <cstring> // memcpy
#include "error.hpp"
#include "global.hpp"
#include "indexed_matrix.hpp"
 
/*============== Template parameter type naming conventions ==============
--------- Numeric types: -------------------------------------------------
DATATYPE - data sample values - usually real numbers (but may be integers
          in text processing etc.)
REALTYPE - must be real numbers - for representing intermediate results of 
          calculations like mean, covariance etc.
IDXTYPE - index values for enumeration of data samples - (nonnegative) integers, 
          extent depends on numbers of samples in data
DIMTYPE - index values for enumeration of features (dimensions), or classes (not 
          class sizes) - (nonnegative) integers, usually lower extent than IDXTYPE, 
          but be aware of expressions like _classes*_features*_features ! 
          in linearized representations of feature matrices for all classes
BINTYPE - feature selection marker type - represents ca. <10 different feature 
          states (selected, deselected, sel./desel. temporarily 1st nested loop, 2nd...)
RETURNTYPE - criterion value: real value, but may be extended in future to support 
          multiple values 
--------- Class types: ---------------------------------------------------
SUBSET       - class of class type Subset 
CLASSIFIER   - class implementing interface defined in abstract class Classifier 
EVALUATOR    - class implementing interface defined in abstract class Sequential_Step 
DISTANCE     - class implementing interface defined in abstract class Distance 
DATAACCESSOR - class implementing interface defined in abstract class Data_Accessor 
INTERVALCONTAINER - class of class type Data_Intervaller 
CONTAINER    - STL container of class type Data_Interval  
========================================================================== */
 
namespace FST {
 
template<typename DATATYPE, typename DIMTYPE, class SUBSET>
class Indexed_Matrix;
 
template<typename DATATYPE, typename DIMTYPE, class SUBSET>
class Indexed_Vector;
 
template<typename DATATYPE, typename DIMTYPE, class SUBSET>
std::ostream& operator<<(std::ostream& os, const Indexed_Vector<DATATYPE,DIMTYPE,SUBSET>& tdb);

template<typename DATATYPE, typename DIMTYPE, class SUBSET>
class Indexed_Vector {
public:
        typedef std::shared_ptr<SUBSET> PSubset; 
        Indexed_Vector() : _n_max(0), _n(0), _d(0) {notify("Indexed_Vector (empty) constructor");}
        Indexed_Vector(const DIMTYPE n)  : _n_max(0), _n(0), _d(0) {notify("Indexed_Vector constructor"); reset(n);} 
        Indexed_Vector(const Indexed_Vector& iv); 
        Indexed_Vector& operator=(Indexed_Vector const &iv); 
        ~Indexed_Vector() {notify("Indexed_Vector destructor");}
        void reset(const DIMTYPE n_max); 
        void redim(const DIMTYPE n=0); 
 
        DATATYPE& operator[](const DIMTYPE i) {assert(i<_n); assert(_data); return _data[i];} 
        DATATYPE& at_raw(const DIMTYPE i) {assert(i<_n); assert(_data); return _data[i];} 
        DATATYPE& at(const DIMTYPE i) {assert(i<_d); assert(_index); return _data[_index[i]];} 
        DATATYPE* get_raw() {return _data.get();} 
        const DATATYPE& operator[](const DIMTYPE i) const {assert(i<_n); assert(_data); return _data[i];} 
        const DATATYPE& at_raw(const DIMTYPE i) const {assert(i<_n); assert(_data); return _data[i];} 
        const DATATYPE& at(const DIMTYPE i) const {assert(i<_d); assert(_index); return _data[_index[i]];} 
        const DATATYPE* get_raw() const {return _data.get();} 

        void narrow_to(const PSubset sub);
        void denarrow(); 
        DIMTYPE get_n() const {return _n;} 
        DIMTYPE get_d() const {return _d;} 
 
        // "raw" operations, ignoring index[]
        void set_all_raw_to(const DATATYPE val); 
        void subtract_raw(const Indexed_Vector& vr); 
        void copy_raw(const Indexed_Vector& vr); 
 
        friend class Indexed_Matrix<DATATYPE,DIMTYPE,SUBSET>;
        friend std::ostream& operator<< <>(std::ostream& os, const Indexed_Vector& tdb); 
        
protected:
        // NOTE: vector size is defined by:
        //       _n_max - hard constant representing maximum allocated space of size _n_max
        //       _n     - "full feature set" dimensionality, _n<=_n_max
        //       _d     - "virtual subset" dimensionality, _d<=_n
        //       (this logic replicates that in Indexed_Matrix, where it is more important)
        DIMTYPE _n_max; 
        DIMTYPE _n; 
        std::unique_ptr<DATATYPE[]> _data; 
        // sub-vector access tools
        DIMTYPE _d; 
        std::unique_ptr<DIMTYPE[]> _index; 
};
 
template<typename DATATYPE, typename DIMTYPE, class SUBSET>
Indexed_Vector<DATATYPE,DIMTYPE,SUBSET>::Indexed_Vector(const Indexed_Vector& iv) : // copy-constructor
        _n_max(iv._n_max),
        _n(iv._n),
        _d(iv._d)
{
        notify("Indexed_Vector copy-constructor.");
        if(_n_max>0)
        {
                _data.reset(new DATATYPE[_n_max]);      memcpy((void *)_data.get(),(void *)(iv._data).get(),sizeof(DATATYPE)*_n_max);
                _index.reset(new DIMTYPE[_n_max]); memcpy((void *)_index.get(),(void *)(iv._index).get(),sizeof(DIMTYPE)*_n_max); // selected features (subspace) - index into _data
        }
}
 
template<typename DATATYPE, typename DIMTYPE, class SUBSET>
Indexed_Vector<DATATYPE,DIMTYPE,SUBSET>& Indexed_Vector<DATATYPE,DIMTYPE,SUBSET>::operator=(Indexed_Vector const &iv)
{
        notify("Indexed_Vector operator=.");
        if (this != &iv)
        {
                _n=iv._n;
                _d=iv._d;
                if(_n_max!=iv._n_max) 
                {
                        _n_max=iv._n_max;
                        if(_n_max>0)
                        {
                                _data.reset(new DATATYPE[_n_max]);      
                                _index.reset(new DIMTYPE[_n_max]); 
                        } else {
                                assert(!iv._data);
                                assert(!iv._index);
                                _data.reset();
                                _index.reset();
                        }
                }
                if(_n_max>0)
                {
                        memcpy((void *)_data.get(),(void *)(iv._data).get(),sizeof(DATATYPE)*_n_max);
                        memcpy((void *)_index.get(),(void *)(iv._index).get(),sizeof(DIMTYPE)*_n_max); // selected features (subspace) - index into _data
                }
        }
        return *this;
}
 
template<typename DATATYPE, typename DIMTYPE, class SUBSET>
void Indexed_Vector<DATATYPE,DIMTYPE,SUBSET>::reset(const DIMTYPE n_max)
{
        notify("Indexed_Vector reset.");
        assert(n_max>0);
        if(n_max!=_n_max) {
                _n_max=n_max;
                _data.reset(new DATATYPE[_n_max]);
                _index.reset(new DIMTYPE[n_max]); // selected features (subspace) - index into _data
        }
        // unconditionally, like Indexed_Matrix::reset — reset() always restores FULL dimensionality
        // and the identity index map, also when the requested size equals the current allocation
        // (it must not leave a stale redim()ed or narrow_to()'d _n/_d behind)
        _n=_d=n_max;
        for(DIMTYPE i=0;i<_n_max;i++) _index[i]=i;
}
 
template<typename DATATYPE, typename DIMTYPE, class SUBSET>
void Indexed_Vector<DATATYPE,DIMTYPE,SUBSET>::redim(const DIMTYPE n)
{
        notify("Indexed_Vector redim.");
        assert(n<=_n_max);
        assert(_data);
        assert(_index);
        if(n==0) _d=_n=_n_max; else _d=_n=n;
        for(DIMTYPE i=0;i<_n;i++) _index[i]=i;
}
 
template<typename DATATYPE, typename DIMTYPE, class SUBSET>
void Indexed_Vector<DATATYPE,DIMTYPE,SUBSET>::narrow_to(const PSubset sub) // fill _index[] -> access to data is then mapped to sub-matrix
{
        assert(_n>=sub->get_d_raw()); // precondition: enough space to store the subset
        assert(_index);
        _d=0;
        for(DIMTYPE f : sub->selected_features()) _index[_d++]=f;
        assert(_d>0);
}
 
template<typename DATATYPE, typename DIMTYPE, class SUBSET>
void Indexed_Vector<DATATYPE,DIMTYPE,SUBSET>::denarrow() // reset _index[] -> access is reset to the full matrix
{
        assert(_index);
        for(DIMTYPE i=0;i<_n;i++) _index[i]=i;
        _d=_n;
}
 
template<typename DATATYPE, typename DIMTYPE, class SUBSET>
void Indexed_Vector<DATATYPE,DIMTYPE,SUBSET>::set_all_raw_to(const DATATYPE val)
{
        assert(_data);
        for(DIMTYPE i=0;i<_n;i++) _data[i]=val;
}
 
template<typename DATATYPE, typename DIMTYPE, class SUBSET>
void Indexed_Vector<DATATYPE,DIMTYPE,SUBSET>::subtract_raw(const Indexed_Vector& mr)
{
        assert(_data);
        assert(mr._data);
        assert(mr.get_n()==_n);
        for(DIMTYPE i=0;i<_n;i++) _data[i]-=mr._data[i];
}
 
template<typename DATATYPE, typename DIMTYPE, class SUBSET>
void Indexed_Vector<DATATYPE,DIMTYPE,SUBSET>::copy_raw(const Indexed_Vector& mr)
{
        assert(_data);
        assert(mr._data);
        assert(mr.get_n()==_n);
        for(DIMTYPE i=0;i<_n;i++) _data[i]=mr._data[i];
}

template<typename DATATYPE, typename DIMTYPE, class SUBSET>
std::ostream& operator<<(std::ostream& os, const Indexed_Vector<DATATYPE,DIMTYPE,SUBSET>& tdb)
{
        assert(tdb._n>0);
        assert(tdb._d>0);
        assert(tdb._data);
        assert(tdb._index);
        os << "----------------"<<std::endl;
        os << "Indexed_Vector::" << std::endl;
        os << "_index: "; for(DIMTYPE j=0;j<tdb._d;j++) {os << tdb._index[j] << " ";} os<<std::endl;
        os << "_data (indexed): "; for(DIMTYPE j=0;j<tdb._d;j++) {os << tdb._data[tdb._index[j]] << " ";} os << std::endl;
        os << "----------------"<<std::endl;
        return os;
}
 
 
} // namespace
#endif // FSTINDEXEDVECTOR_H ///:~