Forming CLEF expressions

In this section, we describe how to form CLEF expressions.

Placeholders

Loosely speaking, a placeholder is a “variable name” used to build an expression. Placeholders are declared as

placeholder<Number> Name;

Example

placeholder <1> x_;
placeholder <2> y_;

Note that the only thing of significance in a placeholder is its type (i.e. a number). A placeholder is empty: it contains no value at runtime.

Warning

As a consequence, defining

placeholder <1> y_;

would imply that x_ is the same as y_: x_ == y_ will be always true.

Forming an expression

CLEF expressions are made of:

  • Placeholders

  • Binary operations on expressions (+, -, *, /, >, <, >=, <=, ==)

  • Ternary conditional if_else expressions

  • Callable objects which overload the operator () for CLEF expressions, See Overloading operator() and other methods.

  • Functions overloaded for CLEF expressions. For example, the header math.hpp contains the declaration to make the basic function of std math.h accept CLEF_expressions.

  • In fact, almost anything: the make_expr function can be called on any object to make it lazy.

Examples:

#include <nda/clef.hpp>
#include <vector>
using namespace nda::clef;
int main() {
  placeholder<0> i_;
  placeholder<1> x_;
  placeholder<2> y_;
  std::vector<int> V;

  // arithmetic
  auto e = x_ + 2 * y_;

  // simple math function
  auto e1 = cos(2 * x_ + 1);
  auto e2 = abs(2 * x_ - 1);

  // making V lazy
  auto e0 = make_expr(V)[i_];
}

Note that:

  • Expressions do not compute anything, they just store the expression tree.

  • There is no check of correctness here in general: an expression can be well formed, but meaningless, e.g.

    auto e = cos(2*x_, 8); // !

Storage of expressions [advanced]

CLEF expressions have a complicated (expression template) type encoding the structure of the expression at compile time:

auto e = x_ + 2* y_;
// the type of e is something like
expr<tags::plus, placeholder<1>, expr<tags::multiplies, int, placeholder<2> >

Note that:

  • As a user, one never has to write such a type. One always use expression “on the fly”, or use auto.

  • Having the whole structure of the expression at compile time allows efficient evaluation (it is the principle of expression template: add a ref here).

  • Declaring an expression does not do any computation. It just stores the expression tree (its structure in the type, and the leaves of the tree).

  • Every object in the expression tree is captured by :

    • documentation/manual/triqs it is an lvalue.

    • value it is an rvalue: an rvalue (i.e. a temporary) is moved into the tree, using move semantics.

    Exceptions: the following objects are always copied: placeholders, expression themselves.

    Example

    double a = 3;
auto e = a + 2* x_ ;  // a is stored by documentation/manual/triqs (double &), but 2 is stored by value

    The rationale is as follows:

    • rvalue must be moved, otherwise we would keep (dangling) documentation/manual/triqs to temporaries.

    • for lvalue, keeping a documentation/manual/triqs is quicker. Of course, in the previous example, it is mandatory that a live longer than e …