stream_multiply.hpp

Go to the documentation of this file.

// vim: set tabstop=2:softtabstop=2:shiftwidth=2:expandtab

#include "../config.hpp"
#include "../traits.hpp"
#include "../types/stream.hpp"

#ifndef LIN_CORE_OPERATIONS_STREAM_MULTIPLY_HPP_
#define LIN_CORE_OPERATIONS_STREAM_MULTIPLY_HPP_

namespace lin {
namespace internal {

template <class C, class D, typename = void>
struct can_multiply : std::false_type { };

template <class C, class D>
struct can_multiply<C, D, std::enable_if_t<(
    is_detected<multiply::template expression, _elem_t<C>, _elem_t<D>>::value &&
    (_dims<C>::cols == _dims<D>::rows) &&
    (_dims<C>::max_cols == _dims<D>::max_rows)
  )>> : std::true_type { };

template <class C, class D>
class StreamMultiply : public Stream<StreamMultiply<C, D>> {
 private:
  Stream<C> const &c;

  Stream<D> const &d;

 public:
  typedef traits<StreamMultiply<C, D>> Traits;

 protected:
  using Stream<StreamMultiply<C, D>>::derived;

 public:
  using Stream<StreamMultiply<C, D>>::size;
  using Stream<StreamMultiply<C, D>>::eval;

  constexpr StreamMultiply() = delete;
  constexpr StreamMultiply(StreamMultiply<C, D> const &) = default;
  constexpr StreamMultiply(StreamMultiply<C, D> &&) = default;
  constexpr StreamMultiply<C, D> &operator=(StreamMultiply<C, D> const &) = default;
  constexpr StreamMultiply<C, D> &operator=(StreamMultiply<C, D> &&) = default;

  constexpr StreamMultiply(Stream<C> const &c, Stream<D> const &d)
  : c(c), d(d) {
    LIN_ASSERT(c.cols() == d.rows());
  }

  constexpr size_t rows() const {
    return c.rows();
  }

  constexpr size_t cols() const {
    return d.cols();
  }

  constexpr typename Traits::elem_t operator()(size_t i, size_t j) const {
    typename Traits::elem_t x = c(i, 0) * d(0, j);
    for (size_t k = 1; k < c.cols(); k++) x += c(i, k) * d(k, j);
    return x;
  }

  constexpr typename Traits::elem_t operator()(size_t i) const {
    return (*this)(i / cols(), i % cols());
  }
};

template <class C, class D>
struct _elem<StreamMultiply<C, D>> {
  typedef typename multiply::template expression<
      typename _elem<C>::type, typename _elem<D>::type
    > type;
};

template <class C, class D>
struct _dims<StreamMultiply<C, D>> {
  static constexpr size_t rows = _dims<C>::rows;
  static constexpr size_t cols = _dims<D>::cols;
  static constexpr size_t max_rows = _dims<C>::max_rows;
  static constexpr size_t max_cols = _dims<D>::max_cols;
};
}  // namespace internal
}  // namespace lin

#endif