estimate_matrix.hpp

Go to the documentation of this file.

//============================================================================
// MCKL/include/mckl/core/estimate_matrix.hpp
//----------------------------------------------------------------------------
// MCKL: Monte Carlo Kernel Library
//----------------------------------------------------------------------------
// Copyright (c) 2013-2018, 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 MCKL_CORE_ESTIMATE_MATRIX_HPP
#define MCKL_CORE_ESTIMATE_MATRIX_HPP

#include <mckl/internal/common.hpp>
#include <mckl/core/matrix.hpp>

namespace mckl {

template <typename T>
class EstimateMatrix : public Matrix<T, RowMajor>
{
  public:
    using matrix_type = Matrix<T, RowMajor>;
    using value_type = typename matrix_type::value_type;
    using size_type = typename matrix_type::size_type;
    using estimate_range = typename matrix_type::row_range;
    using variable_range = typename matrix_type::col_range;
    using const_estimate_range = typename matrix_type::const_row_range;
    using const_variable_range = typename matrix_type::const_col_range;

    EstimateMatrix(size_type dim) : matrix_type(0, dim) {}

    std::size_t dim() const noexcept { return this->ncol(); }

    std::size_t num_iter() const noexcept { return this->nrow(); }

    void clear() { this->resize(0, dim()); }

    void reserve(std::size_t n)
    {
        matrix_type::reserve(num_iter() + n, dim());
    }

    estimate_range estimate(size_type i) { return this->row_range(i); }

    const_estimate_range estimate(size_type i) const
    {
        return this->row_range(i);
    }

    variable_range variable(size_type j) { return this->col_range(j); }

    const_variable_range variable(size_type j) const
    {
        return this->col_range(j);
    }

    T *insert_estimate()
    {
        const size_type i = num_iter();
        this->resize(i + 1, dim());

        return this->row_data(i);
    }

    template <typename InputIter>
    void insert_estimate(InputIter first)
    {
        this->push_back_row(first);
    }

    template <typename InputIter>
    void insert_estimate(size_type i, InputIter first)
    {
        const size_type t = num_iter();
        if (i < t) {
            std::copy_n(first, dim(), this->row_begin(i));
        }
        if (i == t) {
            insert_estimate(first);
        }
        if (i > t) {
            insert_estimate_dispatch(t, i, first, std::is_floating_point<T>());
        }
    }

  private:
    using matrix_type::push_back_col;
    using matrix_type::resize;

    template <typename InputIter>
    void insert_estimate_dispatch(
        size_type t, size_type i, InputIter first, std::true_type)
    {
        insert_estimate_dispatch(t, i, first, std::false_type());
        if (i > t) {
            std::fill_n(this->row_begin(t), (i - t) * dim(), -const_nan<T>());
        }
    }

    template <typename InputIter>
    void insert_estimate_dispatch(
        size_type t, size_type i, InputIter first, std::false_type)
    {
        this->resize(std::max(i + 1, t), dim());
        std::copy_n(first, dim(), this->row_begin(i));
    }
}; // class EstimateMatrix

} // namespace mckl

#endif // MCKL_CORE_ESTIMATE_MATRIX_HPP