mirror of
https://github.com/boostorg/yap.git
synced 2026-01-28 19:52:15 +00:00
107 lines
3.5 KiB
C++
107 lines
3.5 KiB
C++
//[ lazy_vector
|
|
// Defining this allows the assignment below of an expression to a double
|
|
// without writing any specific code to do so.
|
|
#define BOOST_YAP_CONVERSION_OPERATOR_TEMPLATE 1
|
|
#include <boost/yap/expression.hpp>
|
|
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
#include <iostream>
|
|
#include <vector>
|
|
|
|
|
|
template <boost::yap::expr_kind Kind, typename Tuple>
|
|
struct lazy_vector_expr;
|
|
|
|
|
|
// This transform turns a terminal of std::vector<double> into a terminal
|
|
// containing the nth double in that vector. Think of it as turning our
|
|
// expression of vectors into an expression of scalars.
|
|
struct take_nth
|
|
{
|
|
boost::yap::terminal<lazy_vector_expr, double>
|
|
operator() (boost::yap::terminal<lazy_vector_expr, std::vector<double>> const & expr);
|
|
|
|
std::size_t n;
|
|
};
|
|
|
|
// A custom expression template that defines lazy + and - operators that
|
|
// produce expressions, and an eager [] operator that returns the nth element
|
|
// of the expression.
|
|
//[ lazy_vector_decl
|
|
template <boost::yap::expr_kind Kind, typename Tuple>
|
|
struct lazy_vector_expr
|
|
{
|
|
using this_type = lazy_vector_expr<Kind, Tuple>;
|
|
|
|
static const boost::yap::expr_kind kind = Kind;
|
|
|
|
Tuple elements;
|
|
|
|
BOOST_YAP_USER_BINARY_OPERATOR_MEMBER(plus, this_type, ::lazy_vector_expr)
|
|
BOOST_YAP_USER_BINARY_OPERATOR_MEMBER(minus, this_type, ::lazy_vector_expr)
|
|
|
|
// Note that this does not return an expression; it is greedily evaluated.
|
|
auto operator[] (std::size_t n) const;
|
|
};
|
|
//]
|
|
|
|
template <boost::yap::expr_kind Kind, typename Tuple>
|
|
auto lazy_vector_expr<Kind, Tuple>::operator[] (std::size_t n) const
|
|
{ return boost::yap::evaluate(boost::yap::transform(*this, take_nth{n})); }
|
|
|
|
boost::yap::terminal<lazy_vector_expr, double>
|
|
take_nth::operator() (boost::yap::terminal<lazy_vector_expr, std::vector<double>> const & expr)
|
|
{
|
|
double x = boost::yap::value(expr)[n];
|
|
// This move is something of a hack. The move indicates that the terminal
|
|
// should keep the value of x (since, being an rvalue, it may be a
|
|
// temporary), rather than a reference to x. See the "How Expression
|
|
// Operands Are Treated" section of the tutorial for details.
|
|
return boost::yap::make_terminal<lazy_vector_expr, double>(std::move(x));
|
|
}
|
|
|
|
// In order to define the += operator with the semantics we want, it's
|
|
// convenient to derive a terminal type from a terminal instantiation of
|
|
// lazy_vector_expr. note that we could have written a template
|
|
// specialization here instead -- either one would work. That would of course
|
|
// have required more typing.
|
|
struct lazy_vector :
|
|
lazy_vector_expr<
|
|
boost::yap::expr_kind::terminal,
|
|
boost::hana::tuple<std::vector<double>>
|
|
>
|
|
{
|
|
template <boost::yap::expr_kind Kind, typename Tuple>
|
|
lazy_vector & operator+= (lazy_vector_expr<Kind, Tuple> const & rhs)
|
|
{
|
|
std::vector<double> & this_vec = boost::yap::value(*this);
|
|
for (int i = 0, size = (int)this_vec.size(); i < size; ++i) {
|
|
this_vec[i] += rhs[i];
|
|
}
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
int main ()
|
|
{
|
|
lazy_vector v1{{std::vector<double>(4, 1.0)}};
|
|
lazy_vector v2{{std::vector<double>(4, 2.0)}};
|
|
lazy_vector v3{{std::vector<double>(4, 3.0)}};
|
|
|
|
double d1 = (v2 + v3)[2];
|
|
std::cout << d1 << "\n";
|
|
|
|
v1 += v2 - v3;
|
|
std::cout << '{' << v1[0] << ',' << v1[1]
|
|
<< ',' << v1[2] << ',' << v1[3] << '}' << "\n";
|
|
|
|
// This expression is disallowed because it does not conform to the
|
|
// implicit grammar. operator+= is only defined on terminals, not
|
|
// arbitrary expressions.
|
|
// (v2 + v3) += v1;
|
|
|
|
return 0;
|
|
}
|
|
//]
|