More expressions "improvements"

[bendudson]

Built on top of PR #1750 , this adds some features for making complex expressions in the input file easier to read / organise.

Local Scope

Adds syntax to define local scope. Underneath this inserts a FieldGenerator which modifies the Context object. One use is to simplify expressions using local variables, for efficiency and readability e.g. ensuring that a value is positive:

positive_value = H(expression) * expression

where the expression would be evaluated twice. This can be replaced by:

positive_value = [value = expression]( H({value}) * {value} )

This mechanism can also be used to implement simple functions

mycosh = 0.5 * (exp({arg}) + exp(-{arg}))

which can be called by defining a new Context:

result = [arg = x*2](mycosh)

(a sort of dynamic scope system)

so we could write:

floor = H({arg}) * {arg}
positive_value = [arg = expression](floor)

where function

Adds a where(test, gt0, lt0) function to FieldFactory. This enables more clear swiching than the H(x) Heaviside function. Like the C++ functions in BOUT++, one of two expressions is evaluated,
depending on the sign of the first expression.

Multi-line expressions

Enable multi-line expressions in input options, since long expressions can become hard to read in the options file if all on one line. This adopts the Python approach, where if there are unbalanced brackets ('()' or '[]') then the expression continues on the next line.

In the BOUT.inp file we can therefore write

value = (something
         + more
         - things)

or define complex expression using a Context scope:

result = [a = expression,
          b = something](
            {a} + {b})

sum function for looping

Add a sum function enables a simple kind of loop, but one which is guaranteed to finish. Iterates a given symbol from 0 to count-1, evaluating and summing a given expression. Example:

sum(i, 4, {i}^2)  # => 0^2 + 1^2 + 2^2 + 3^3

Recursive expressions

By default recursive expressions are not allowed in the input options. These can be enabled by setting input:max_recursion_depth != 0 e.g.:

[input]
max_recursion_depth = 10  # 0 = none, -1 = unlimited

By putting a limit on the depth we avoid the halting problem at least, and expressions should (eventually) terminate, preferably before they overflow the stack.

As is traditional, I present to you the Fibonacci sequence:

fib = where({n} - 2.5,
            [n={n}-1](fib) + [n={n}-2](fib),
            1)

so if n = 1 or 2 then fib = 1, but if n = 3 or above then the recursion fun begins.

And another ill-considered language is born. Sorry, I think it was inevitable.

[ZedThree]

Another way of writing this, using std algorithms:

auto count_brackets = [](const std::string& input) {
  return std::count_if(begin(input), end(input), [](const char& ch) { return ch == '(' or ch == '['; }) 
       - std::count_if(begin(input), end(input), [](const char& ch) { return ch == ')' or ch == ']'; });
}

[bendudson]

Thanks yes that would work. It traverses the string twice, but it is nicer in many ways. I'll change to this.