particle.hpp

Go to the documentation of this file.

//============================================================================
// vSMC/include/vsmc/core/particle.hpp
//----------------------------------------------------------------------------
//                         vSMC: Scalable Monte Carlo
//----------------------------------------------------------------------------
// Copyright (c) 2013,2014, Yan Zhou
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
//
//   Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//============================================================================

#ifndef VSMC_CORE_PARTICLE_HPP
#define VSMC_CORE_PARTICLE_HPP

#include <vsmc/internal/common.hpp>
#include <vsmc/core/single_particle.hpp>
#include <vsmc/core/weight_set.hpp>
#include <vsmc/resample/resample.hpp>
#include <vsmc/rng/rng_set.hpp>
#include <vsmc/rng/seed.hpp>
#include <vsmc/utility/aligned_memory.hpp>

namespace vsmc {

template <typename T>
class Particle
{
    public :

    typedef typename traits::SizeTypeTrait<T>::type size_type;
    typedef T value_type;
    typedef typename traits::WeightSetTypeTrait<T>::type weight_set_type;
    typedef typename traits::RngSetTypeTrait<T>::type rng_set_type;
    typedef typename traits::ResampleRngTypeTrait<T>::type resample_rng_type;
    typedef typename rng_set_type::rng_type rng_type;
    typedef SingleParticle<T> sp_type;
    typedef ConstSingleParticle<T> csp_type;

    typedef cxx11::function<void (std::size_t, std::size_t,
            resample_rng_type &, const double *, size_type *)> resample_type;
    typedef typename traits::ResampleCopyFromReplicationTypeTrait<T>::type
        resample_copy_from_replication_type;
    typedef typename traits::ResamplePostCopyTypeTrait<T>::type
        resample_post_copy_type;

    explicit Particle (size_type N) :
        size_(N), value_(N),
        weight_set_(static_cast<typename
                traits::SizeTypeTrait<weight_set_type>::type>(N)),
        rng_set_(static_cast<typename
                traits::SizeTypeTrait<rng_set_type>::type>(N)),
        resample_rng_(Seed::instance().get()) {}

    Particle<T> clone (bool new_rng) const
    {
        Particle<T> particle(*this);
        if (new_rng) {
            particle.rng_set().seed();
            particle.resample_rng().seed(Seed::instance().get());
        }

        return particle;
    }

    Particle<T> &clone (const Particle<T> &other, bool retain_rng)
    {
        if (this != &other) {
            if (retain_rng) {
#if VSMC_HAS_CXX11_RVALUE_REFERENCES
                rng_set_type rset(cxx11::move(rng_set_));
                resample_rng_type rrng(cxx11::move(resample_rng_));
                *this = other;
                rng_set_ = cxx11::move(rset);
                resample_rng_ = cxx11::move(rrng);
#else
                using std::swap;

                rng_set_type rset(0);
                swap(rset, rng_set_);
                resample_rng_type rrng(resample_rng_);
                *this = other;
                swap(rset, rng_set_);
                resample_rng_ = rrng;
#endif
                rng_set_.resize(other.size());
            } else {
                *this = other;
            }
        }

        return *this;
    }

#if VSMC_HAS_CXX11_RVALUE_REFERENCES
    Particle<T> &clone (Particle<T> &&other, bool retain_rng)
    {
        if (this != &other) {
            if (retain_rng) {
                rng_set_type rset(cxx11::move(rng_set_));
                resample_rng_type rrng(cxx11::move(resample_rng_));
                *this = cxx11::move(other);
                rng_set_ = cxx11::move(rset);
                resample_rng_ = cxx11::move(rrng);
                rng_set_.resize(other.size());
            } else {
                *this = cxx11::move(other);
            }
        }

        return *this;
    }
#endif

    size_type size () const {return size_;}

    value_type &value () {return value_;}

    const value_type &value () const {return value_;}

    weight_set_type &weight_set () {return weight_set_;}

    const weight_set_type &weight_set () const {return weight_set_;}

    rng_set_type &rng_set () {return rng_set_;}

    const rng_set_type &rng_set () const {return rng_set_;}

    rng_type &rng (size_type id) {return rng_set_[id];}

    sp_type sp (size_type id) {return sp_type(id, this);}

    csp_type sp (size_type id) const {return csp_type(id, this);}

    csp_type csp (size_type id) {return csp_type(id, this);}

    csp_type csp (size_type id) const {return csp_type(id, this);}

    resample_rng_type &resample_rng () {return resample_rng_;}

    bool resample (const resample_type &op, double threshold)
    {
        std::size_t N = static_cast<std::size_t>(weight_set_.resample_size());
        bool resampled = weight_set_.ess() < threshold * N;
        if (resampled) {
            size_type *cptr = VSMC_NULLPTR;
            const double *wptr = weight_set_.resample_weight_data();
            if (wptr != VSMC_NULLPTR) {
                resample_copy_from_.resize(N);
                resample_replication_.resize(N);
                cptr = &resample_copy_from_[0];
                size_type *rptr = &resample_replication_[0];
                op(N, N, resample_rng_, wptr, rptr);
                resample_copy_from_replication_(N, N, rptr, cptr);
            }
            value_.copy(N, cptr);
            resample_post_copy_(weight_set_);
        }

        return resampled;
    }

    private :

    size_type size_;
    value_type value_;
    weight_set_type weight_set_;
    rng_set_type rng_set_;
    resample_rng_type resample_rng_;

    std::vector<size_type, AlignedAllocator<size_type> > resample_copy_from_;
    std::vector<size_type, AlignedAllocator<size_type> > resample_replication_;
    resample_copy_from_replication_type resample_copy_from_replication_;
    resample_post_copy_type resample_post_copy_;
}; // class Particle

} // namespace vsmc

#endif // VSMC_CORE_PARTICLE_HPP