dataset.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef __LEMGA_DATASET_H__
#define __LEMGA_DATASET_H__

#include <vector>
#include <utility>
#include "random.h"

namespace lemga {

template <typename Tx, typename Ty>
class dataset {
    std::vector< std::pair<Tx,Ty> > d;

public:
    typedef Tx x_type;
    typedef Ty y_type;

    dataset () : d() {}

    UINT size () const { return d.size(); }
    bool empty () const { return d.empty(); }
    void clear () { d.clear(); }
    const Tx& x (UINT i) const { return d[i].first; }
    const Ty& y (UINT i) const { return d[i].second; }

    template <typename IIX, typename IIY>
    dataset (IIX xb, IIX xe, IIY yb, IIY ye) { import(xb, xe, yb, ye); }

    template <typename IIX, typename IIY>
    void import (IIX xb, IIX xe, IIY yb, IIY ye) {
        d.clear();
        d.reserve(xe - xb);
        for (; xb != xe && yb != ye; ++xb, ++yb)
            append(*xb, *yb);
    }


    dataset* random_sample (UINT n) const {
        const UINT dn = d.size();
        assert(n == 0 || dn > 0);

        dataset* rd = new dataset();
        rd->d.reserve(n);
        while (n--) {
            const UINT sel = UINT(randu() * dn);
            assert(sel < dn);
            rd->d.push_back(d[sel]);
        }
        return rd;
    }

    template <typename W>
    dataset* random_sample (const W& wgt, UINT n) const {
        const UINT dn = d.size();
        assert(n == 0 || dn > 0);

        std::vector<PROBAB> cdf(dn+1);
        cdf[0] = 0;
        for (UINT i = 0; i < dn; ++i)
            cdf[i+1] = cdf[i] + wgt[i];
        assert(cdf[dn]-1 > -EPSILON && cdf[dn]-1 < EPSILON);

        dataset* rd = new dataset();
        rd->d.reserve(n);
        while (n--) {
            const PROBAB r = randu();

            UINT b = 0, e = dn, m;
            while (b+1 < e) {
                m = (b + e) / 2;
                if (r < cdf[m]) e = m;
                else b = m;
            }

            rd->d.push_back(d[b]);
        }
        return rd;
    }

    dataset& operator+= (const dataset& ds) {
        const UINT n = ds.d.size();
        d.reserve(d.size() + n);
        for (UINT i = 0; i < n; ++i)
            d.push_back(ds.d[i]);
        return *this;
    }

    void append (const Tx& _x, const Ty& _y) {
        d.resize(d.size()+1);           // 1 constructor + 1 copy
        d.back().first = _x;            // 1 copy
        d.back().second = _y;
        //d.push_back(make_pair(_x, _y));   // 2 copy
    }

    void replace (UINT i, const Tx& _x, const Ty& _y) {
        assert (i < d.size());
        d[i].first = _x;
        d[i].second = _y;
    }
};

} // namespace lemga

#ifdef  __DATASET_H__
#warning "This header file may conflict with another `dataset.h' file."
#endif
#define __DATASET_H__
#endif

---