lol/tools/lolremez/expression.h

//
//  LolRemez — Remez algorithm implementation
//
//  Copyright © 2005—2015 Sam Hocevar <sam@hocevar.net>
//
//  This program is free software. It comes without any warranty, to
//  the extent permitted by applicable law. You can redistribute it
//  and/or modify it under the terms of the Do What the Fuck You Want
//  to Public License, Version 2, as published by the WTFPL Task Force.
//  See http://www.wtfpl.net/ for more details.
//

#pragma once

//
// Powerful arithmetic expression parser/evaluator
//
// Usage:
//   expression e;
//   e.parse(" 2*x^3 + 3 * sin(x - atan(x))");
//   auto y = e.eval("1.5");
//

#include "pegtl.hh"

namespace grammar
{

using namespace pegtl;

enum class id : uint8_t
{
    /* Variables and constants */
    x,
    constant,
    /* Unary functions/operators */
    plus, minus, abs,
    sqrt, cbrt,
    exp, exp2, log, log2, log10,
    sin, cos, tan,
    asin, acos, atan,
    sinh, cosh, tanh,
    /* Binary functions/operators */
    add, sub, mul, div,
    atan2, pow,
    min, max,
};

struct expression
{
    /*
     * Evaluate expression at x
     */
    lol::real eval(lol::real const &x) const
    {
        /* Use a stack */
        lol::array<lol::real> stack;

        for (int i = 0; i < m_ops.count(); ++i)
        {
            /* Rules that do not consume stack elements */
            if (m_ops[i].m1 == id::x)
            {
                stack.push(x);
                continue;
            }
            else if (m_ops[i].m1 == id::constant)
            {
                stack.push(m_constants[m_ops[i].m2]);
                continue;
            }

            /* All other rules consume at least the head of the stack */
            lol::real head = stack.pop();

            switch (m_ops[i].m1)
            {
            case id::plus:  stack.push(head);  break;
            case id::minus: stack.push(-head); break;

            case id::abs:   stack.push(fabs(head));  break;
            case id::sqrt:  stack.push(sqrt(head));  break;
            case id::cbrt:  stack.push(cbrt(head));  break;
            case id::exp:   stack.push(exp(head));   break;
            case id::exp2:  stack.push(exp2(head));  break;
            case id::log:   stack.push(log(head));   break;
            case id::log2:  stack.push(log2(head));  break;
            case id::log10: stack.push(log10(head)); break;
            case id::sin:   stack.push(sin(head));   break;
            case id::cos:   stack.push(cos(head));   break;
            case id::tan:   stack.push(tan(head));   break;
            case id::asin:  stack.push(asin(head));  break;
            case id::acos:  stack.push(acos(head));  break;
            case id::atan:  stack.push(atan(head));  break;
            case id::sinh:  stack.push(sinh(head));  break;
            case id::cosh:  stack.push(cosh(head));  break;
            case id::tanh:  stack.push(tanh(head));  break;

            case id::add:   stack.push(stack.pop() + head); break;
            case id::sub:   stack.push(stack.pop() - head); break;
            case id::mul:   stack.push(stack.pop() * head); break;
            case id::div:   stack.push(stack.pop() / head); break;

            case id::atan2: stack.push(atan2(stack.pop(), head)); break;
            case id::pow:   stack.push(pow(stack.pop(), head));   break;
            case id::min:   stack.push(min(stack.pop(), head));   break;
            case id::max:   stack.push(max(stack.pop(), head));   break;

            case id::x:
            case id::constant:
                /* Already handled above */
                break;
            }
        }

        ASSERT(stack.count() == 1);
        return stack.pop();
    }

private:
    lol::array<id, int> m_ops;
    lol::array<lol::real> m_constants;

private:
    struct r_expr;

    // r_ <- <blank> *
    struct _ : star<space> {};

    // r_constant <- <digit> + ( "." <digit> * ) ? ( [eE] [+-] ? <digit> + ) ?
    struct r_constant : seq<plus<digit>,
                            opt<seq<one<'.'>,
                                    star<digit>>>,
                            opt<seq<one<'e', 'E'>,
                                    opt<one<'+', '-'>>,
                                    plus<digit>>>> {};

    // r_var <- "x"
    struct r_var : pegtl_string_t("x") {};

    // r_binary_call <- <r_binary_fun> "(" r_expr "," r_expr ")"
    struct r_binary_fun : sor<pegtl_string_t("atan2"),
                              pegtl_string_t("pow"),
                              pegtl_string_t("min"),
                              pegtl_string_t("max")> {};

    struct r_binary_call : seq<r_binary_fun,
                               _, one<'('>,
                               _, r_expr,
                               _, one<','>,
                               _, r_expr,
                               _, one<')'>> {};

    // r_unary_call <- <r_unary_fun> "(" r_expr ")"
    struct r_unary_fun : sor<pegtl_string_t("abs"),
                             pegtl_string_t("sqrt"),
                             pegtl_string_t("cbrt"),
                             pegtl_string_t("exp"),
                             pegtl_string_t("exp2"),
                             pegtl_string_t("log"),
                             pegtl_string_t("log2"),
                             pegtl_string_t("log10"),
                             pegtl_string_t("sin"),
                             pegtl_string_t("cos"),
                             pegtl_string_t("tan"),
                             pegtl_string_t("asin"),
                             pegtl_string_t("acos"),
                             pegtl_string_t("atan"),
                             pegtl_string_t("sinh"),
                             pegtl_string_t("cosh"),
                             pegtl_string_t("tanh")> {};

    struct r_unary_call : seq<r_unary_fun,
                              _, one<'('>,
                              _, r_expr,
                              _, one<')'>> {};

    // r_call <- r_binary_call / r_unary_call
    struct r_call : sor<r_binary_call,
                        r_unary_call> {};

    // r_parentheses <- "(" r_expr ")"
    struct r_parentheses : seq<one<'('>,
                               pad<r_expr, space>,
                               one<')'>> {};

    // r_terminal <- r_call / r_var / r_constant / r_parentheses
    struct r_terminal : sor<r_call,
                            r_var,
                            r_constant,
                            r_parentheses> {};

    // r_signed <- "-" r_signed / "+" r_signed / r_terminal
    struct r_signed;
    struct r_minus : seq<one<'-'>, _, r_signed> {};
    struct r_signed : sor<r_minus,
                          seq<one<'+'>, _, r_signed>,
                          r_terminal> {};

    // r_exponent <- ( "^" / "**" ) r_signed
    struct r_exponent : seq<pad<sor<one<'^'>,
                                    string<'*', '*'>>, space>,
                            r_signed> {};

    // r_factor <- r_signed ( r_exponent ) *
    struct r_factor : seq<r_signed,
                          star<r_exponent>> {};

    // r_mul <- "*" r_factor
    // r_div <- "/" r_factor
    // r_term <- r_factor ( r_mul / r_div ) *
    struct r_mul : seq<_, one<'*'>, _, r_factor> {};
    struct r_div : seq<_, one<'/'>, _, r_factor> {};
    struct r_term : seq<r_factor,
                        star<sor<r_mul, r_div>>> {};

    // r_add <- "+" r_term
    // r_sub <- "-" r_term
    // r_expr <- r_term ( r_add / r_sub ) *
    struct r_add : seq<_, one<'+'>, _, r_term> {};
    struct r_sub : seq<_, one<'-'>, _, r_term> {};
    struct r_expr : seq<r_term,
                        star<sor<r_add, r_sub>>> {};

    // r_stmt <- r_expr <end>
    struct r_stmt : must<pad<r_expr, space>, pegtl::eof> {};

    //
    // Default actions
    //

    template<typename R>
    struct action : nothing<R> {};

    template<id OP>
    struct generic_action
    {
        static void apply(action_input const &in, expression *that)
        {
            UNUSED(in);
            that->m_ops.push(OP, -1);
        }
    };

public:
    /*
     * Parse arithmetic expression in x, e.g. 2*x+3
     */
    void parse(std::string const &str)
    {
        m_ops.empty();
        m_constants.empty();

        pegtl::parse_string<r_stmt, action>(str, "expression", this);
    }
};

//
// Rule specialisations for simple operators
//

template<> struct expression::action<expression::r_var> : generic_action<id::x> {};
template<> struct expression::action<expression::r_exponent> : generic_action<id::pow> {};
template<> struct expression::action<expression::r_mul> : generic_action<id::mul> {};
template<> struct expression::action<expression::r_div> : generic_action<id::div> {};
template<> struct expression::action<expression::r_add> : generic_action<id::add> {};
template<> struct expression::action<expression::r_sub> : generic_action<id::sub> {};
template<> struct expression::action<expression::r_minus> : generic_action<id::minus> {};

//
// Rule specialisations for unary and binary function calls
//

template<>
struct expression::action<expression::r_binary_call>
{
    static void apply(action_input const &in, expression *that)
    {
        struct { id ret; char const *name; } lut[] =
        {
            { id::atan2, "atan2" },
            { id::pow,   "pow" },
            { id::min,   "min" },
            { id::max,   "max" },
        };

        for (auto pair : lut)
        {
            if (strncmp(in.string().c_str(), pair.name, strlen(pair.name)) != 0)
                continue;

            that->m_ops.push(pair.ret, -1);
            return;
        }
    }
};

template<>
struct expression::action<expression::r_unary_call>
{
    static void apply(action_input const &in, expression *that)
    {
        struct { id ret; char const *name; } lut[] =
        {
            { id::abs,   "abs" },
            { id::sqrt,  "sqrt" },
            { id::cbrt,  "cbrt" },
            { id::exp2,  "exp2" },
            { id::exp,   "exp" },
            { id::log10, "log10" },
            { id::log2,  "log2" },
            { id::log,   "log" },
            { id::sinh,  "sinh" },
            { id::cosh,  "cosh" },
            { id::tanh,  "tanh" },
            { id::sin,   "sin" },
            { id::cos,   "cos" },
            { id::tan,   "tan" },
            { id::asin,  "asin" },
            { id::acos,  "acos" },
            { id::atan,  "atan" },
        };

        for (auto pair : lut)
        {
            if (strncmp(in.string().c_str(), pair.name, strlen(pair.name)) != 0)
                continue;

            that->m_ops.push(pair.ret, -1);
            return;
        }
    }
};

template<>
struct expression::action<expression::r_constant>
{
    static void apply(action_input const &in, expression *that)
    {
        /* FIXME: check if the constant is already in the list */
        that->m_ops.push(id::constant, that->m_constants.count());
        that->m_constants.push(lol::real(in.string().c_str()));
    }
};

} /* namespace grammar */

using grammar::expression;