core.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 1998-2018 ALPS Collaboration. See COPYRIGHT.TXT
 * All rights reserved. Use is subject to license terms. See LICENSE.TXT
 * For use in publications, see ACKNOWLEDGE.TXT
 */
#pragma once

#include <cstddef>
#include <cassert>
#include <stdexcept>
#include <complex>
#include <string>
#include <vector>
#include <initializer_list>

#include <Eigen/Dense>

#include <alps/alea/complex_op.hpp>

namespace alps { namespace alea {

using std::size_t;
using std::ptrdiff_t;

struct size_mismatch : public std::exception { };

struct unsupported_operation : public std::exception { };

struct finalized_accumulator : public std::exception { };

struct weight_mismatch : public std::exception { };

template <typename T>
struct traits;

// Metafunction to detect ALEA accumulator types
template<typename T> struct is_alea_acc : std::false_type {};

// Metafunction to detect ALEA result types
template<typename T> struct is_alea_result : std::false_type {};

template <typename T>
class view
{
public:
    typedef T value_type;

public:
    view() : data_(nullptr), size_(0) { }

    view(T *data, size_t size)
        : data_(data), size_(size)
    { }

    T *data() { return data_; }

    const T *data() const { return data_; }

    size_t size() const { return size_; }

private:
    T *data_;
    size_t size_;
};

template <typename T>
class ndview
    : public view<T>
{
public:
    typedef T value_type;

public:
    ndview() : view<T>(), shape_(nullptr), ndim_(0) { }

    ndview(T *data, const size_t *shape, size_t ndim)
        : view<T>(data, compute_size(shape, ndim))
        , shape_(shape)
        , ndim_(ndim)
    { }

    ndview(T *data, size_t size, const size_t *shape, size_t ndim)
        : view<T>(data, size)
        , shape_(shape)
        , ndim_(ndim)
    {
        assert(size == compute_size(shape, ndim));
    }

    const size_t *shape() const { return shape_; }

    size_t ndim() const { return ndim_; }

protected:
    static size_t compute_size(const size_t *shape, size_t ndim)
    {
        size_t result = 1;
        for (size_t d = 0; d != ndim; ++d)
            result *= shape[d];
        return result;
    }

private:
    const size_t *shape_;
    size_t ndim_;
};

template <typename T>
struct computed
{
    typedef T value_type;

    virtual size_t size() const = 0;

    virtual std::vector<size_t> shape() const { return std::vector<size_t>(1, size()); }

    virtual void add_to(view<T> out) const = 0;

    virtual computed *clone() { throw unsupported_operation(); }

    virtual ~computed() { }
};

template <typename T>
class column
    : public Eigen::Matrix<T, Eigen::Dynamic, 1>
{
public:
    column() : Eigen::Matrix<T, Eigen::Dynamic, 1>() {}

    column(size_t size) : Eigen::Matrix<T, Eigen::Dynamic, 1>(size) {}

    column(std::initializer_list<T> l) : column(l.size()) {
      size_t i = 0;
      for (auto x : l) {
        this->Eigen::Matrix<T,Eigen::Dynamic,1>::operator()(i) = x;
        ++i;
      }
    }

    template <typename OtherDerived>
    column(const Eigen::MatrixBase<OtherDerived>& other)
        : Eigen::Matrix<T, Eigen::Dynamic, 1>(other) { }

    template<typename OtherDerived>
    column& operator=(const Eigen::MatrixBase <OtherDerived>& other)
    {
        this->Eigen::Matrix<T, Eigen::Dynamic, 1>::operator=(other);
        return *this;
    }

    // Methods for convenience and backwards compatibility

    // TODO this prevents us from doing, which we should be at some point ...
    // template <typename T>
    // using column = Eigen::Matrix<T, Eigen::Dynamic, 1>;

    size_t size() const { return this->rows(); }

    operator std::vector<T>() const
    {
        return std::vector<T>(this->data(), this->data() + this->rows());
    }
};

struct reducer_setup
{
    size_t pos;

    size_t count;

    bool have_result;
};

struct reducer
{
    virtual reducer_setup get_setup() const = 0;

    virtual long get_max(long value) const = 0;

    virtual void reduce(view<double> data) const = 0;

    virtual void reduce(view<long> data) const = 0;

    virtual void commit() const = 0;

    virtual reducer *clone() { throw unsupported_operation(); }

    virtual ~reducer() { }

    // Convenience functions

    void reduce(view<std::complex<double> > data) const {
        reduce(view<double>((double *)data.data(), 2 * data.size()));
    }
    void reduce(view<complex_op<double> > data) const {
        reduce(view<double>((double *)data.data(), 4 * data.size()));
    }
    void reduce(view<unsigned long> data) const {
        reduce(view<long>((long *)data.data(), data.size()));
    }
};

struct serializer
{
    virtual void enter(const std::string &group) = 0;

    virtual void exit() = 0;

    virtual void write(const std::string &key, ndview<const double>) = 0;

    virtual void write(const std::string &key, ndview<const std::complex<double>>) = 0;

    virtual void write(const std::string &key, ndview<const complex_op<double>>) = 0;

    virtual void write(const std::string &key, ndview<const long>) = 0;

    virtual void write(const std::string &key, ndview<const unsigned long>) = 0;

    virtual serializer *clone() { throw unsupported_operation(); }

    virtual ~serializer() { }
};

struct deserializer
{
    virtual void enter(const std::string &group) = 0;

    virtual void exit() = 0;

    virtual std::vector<size_t> get_shape(const std::string &key) = 0;

    virtual void read(const std::string &key, ndview<double>) = 0;

    virtual void read(const std::string &key, ndview<std::complex<double>>) = 0;

    virtual void read(const std::string &key, ndview<complex_op<double>>) = 0;

    virtual void read(const std::string &key, ndview<long>) = 0;

    virtual void read(const std::string &key, ndview<unsigned long>) = 0;

    virtual deserializer *clone() { throw unsupported_operation(); }

    virtual ~deserializer() { }
};

template <typename T>
struct transformer
{
    virtual column<T> operator() (const column<T> &in) const = 0;

    virtual size_t in_size() const = 0;

    virtual size_t out_size() const = 0;

    virtual bool is_linear() const { return false; }

    virtual ~transformer() { }
};

}}