Expr.h

Go to the documentation of this file.

#pragma once
 
#ifndef _EXPR_H_
#define _EXPR_H_
 
#ifdef DEBUG
#define BOOST_SPIRIT_QI_DEBUG
#endif // DEBUG
 
#define _USE_MATH_DEFINES
#include <math.h>
 
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/io.hpp>
#include <boost/phoenix.hpp>
#include <boost/phoenix/object.hpp>
#include <boost/spirit/include/qi.hpp>
 
#include <algorithm>
#include <cmath>
#include <optional>
#include <string>
#include <variant>
#include <vector>
 
namespace qasm
{
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
namespace phx = boost::phoenix;
 
class AbstractSyntaxTree
{
  public:
    virtual ~AbstractSyntaxTree() = default;
 
    virtual double Eval() const
    {
        return 0;
    }
 
    virtual double Eval(const std::unordered_map<std::string, double> &variables) const
    {
        return 0;
    }
 
  protected:
    AbstractSyntaxTree() = default;
    AbstractSyntaxTree(const AbstractSyntaxTree &) = default;
    AbstractSyntaxTree(AbstractSyntaxTree &&) = default;
    AbstractSyntaxTree &operator=(const AbstractSyntaxTree &) = default;
    AbstractSyntaxTree &operator=(AbstractSyntaxTree &&) = default;
};
 
typedef std::shared_ptr<AbstractSyntaxTree> AbstractSyntaxTreePtr;
 
template <typename Expr> static AbstractSyntaxTreePtr Clone(Expr const &t)
{
    return std::make_shared<Expr>(t);
}
 
// for expressions (to be evaluated, typically those are values for parameters
// for gates)
 
class Constant : public AbstractSyntaxTree
{
  public:
    Constant(double value = 0) : value(value)
    {
    }
 
    Constant(int value) : value(value)
    {
    }
 
    Constant &operator=(int value)
    {
        this->value = value;
        return *this;
    }
 
    Constant &operator=(double value)
    {
        this->value = value;
        return *this;
    }
 
    double Eval() const override
    {
        return value;
    }
 
    double Eval(const std::unordered_map<std::string, double> &variables) const override
    {
        return value;
    }
 
  private:
    double value;
};
 
struct MakeConstantExpression
{
    template <typename> struct result
    {
        typedef Constant type;
    };
 
    template <typename C> Constant operator()(C op) const
    {
        return Constant(op);
    }
};
 
inline phx::function<MakeConstantExpression> MakeConstant;
 
class Variable : public AbstractSyntaxTree
{
  public:
    Variable(const std::string &value = "") : value(value)
    {
    }
 
    Variable &operator=(int value)
    {
        this->value = value;
        return *this;
    }
 
    double Eval() const override
    {
        return 0;
    }
 
    double Eval(const std::unordered_map<std::string, double> &variables) const override
    {
        auto it = variables.find(value);
        if (it != variables.end())
            return it->second;
        else
            throw std::invalid_argument("Variable not found: " + value);
 
        return 0;
    }
 
  private:
    std::string value;
};
 
struct MakeVariableExpression
{
    template <typename> struct result
    {
        typedef Variable type;
    };
 
    template <typename V> Variable operator()(V v) const
    {
        return Variable(v);
    }
};
 
inline phx::function<MakeVariableExpression> MakeVariable;
 
// Operator codes are the source characters, with one exception: 'X' stands
// for bitwise XOR. QASM2 spells exponentiation '^' and QASM3 spells it '**'
// while giving '^' to bitwise XOR, so the two meanings cannot share a code -
// '^' is kept for exponentiation (built by both the QASM2 '^' rule and the
// '**' rule) and XOR gets its own. Which node is built is decided by the
// grammar, per language version; see `factor2`/`expression` in Qasm.h.
class BinaryOperator : public AbstractSyntaxTree
{
  public:
    template <typename L, typename R> BinaryOperator(char op, const L &left, const R &right) : op(op), left(Clone(left)), right(Clone(right))
    {
    }
 
    double Eval() const override
    {
        switch (op)
        {
        case '+':
            return left->Eval() + right->Eval();
        case '-':
            return left->Eval() - right->Eval();
        case '*':
            return left->Eval() * right->Eval();
        case '/':
            return left->Eval() / right->Eval();
        case '^':
            return pow(left->Eval(), right->Eval());
        case 'X':
            return static_cast<double>(AsInteger(left->Eval()) ^ AsInteger(right->Eval()));
        default:
            throw std::invalid_argument("Unknown binary operator");
        }
 
        return 0;
    }
 
    double Eval(const std::unordered_map<std::string, double> &variables) const override
    {
        switch (op)
        {
        case '+':
            return left->Eval(variables) + right->Eval(variables);
        case '-':
            return left->Eval(variables) - right->Eval(variables);
        case '*':
            return left->Eval(variables) * right->Eval(variables);
        case '/':
            return left->Eval(variables) / right->Eval(variables);
        case '^':
            return pow(left->Eval(variables), right->Eval(variables));
        case 'X':
            return static_cast<double>(AsInteger(left->Eval(variables)) ^ AsInteger(right->Eval(variables)));
        default:
            throw std::invalid_argument("Unknown binary operator");
        }
 
        return 0;
    }
 
  private:
    // Bitwise XOR is only defined on integers, but every value in this
    // expression tree is a double. A non-integral or out-of-range operand is
    // rejected by name rather than truncated: truncating would turn e.g.
    // `rx(0.5 ^ 1)` into a silently wrong rotation angle, which is exactly the
    // failure mode QASM3's '^' was introducing here in the first place.
    static long long AsInteger(double value)
    {
        if (!std::isfinite(value))
            throw std::invalid_argument("Bitwise XOR ('^') requires finite integer operands, got: " + std::to_string(value));
 
        const double rounded = std::round(value);
 
        if (std::abs(value - rounded) > 1e-9)
            throw std::invalid_argument("Bitwise XOR ('^') requires integer operands, got: " + std::to_string(value));
 
        // The magnitude bound keeps the cast below defined; anything near it is
        // far outside the range of a meaningful gate parameter anyway.
        if (std::abs(rounded) > 4.5e15)
            throw std::invalid_argument("Bitwise XOR ('^') operand is out of the supported integer range: " + std::to_string(value));
 
        return static_cast<long long>(rounded);
    }
 
    char op;
    AbstractSyntaxTreePtr left, right;
};
 
struct MakeBinaryExpression
{
    template <typename, typename, typename> struct result
    {
        typedef BinaryOperator type;
    };
 
    template <typename C, typename L, typename R> BinaryOperator operator()(C op, const L &lhs, const R &rhs) const
    {
        return BinaryOperator(op, lhs, rhs);
    }
};
 
inline phx::function<MakeBinaryExpression> MakeBinary;
 
class UnaryOperator : public AbstractSyntaxTree
{
  public:
    UnaryOperator() : op('+')
    {
    }
 
    template <typename R> UnaryOperator(char op, const R &right) : op(op), right(Clone(right))
    {
    }
 
    double Eval() const override
    {
        switch (op)
        {
        case '+':
            return right->Eval();
        case '-':
            return -right->Eval();
        default:
            throw std::invalid_argument("Unknown unary operator");
        }
 
        return 0;
    }
 
    double Eval(const std::unordered_map<std::string, double> &variables) const override
    {
        switch (op)
        {
        case '+':
            return right->Eval(variables);
        case '-':
            return -right->Eval(variables);
        default:
            throw std::invalid_argument("Unknown unary operator");
        }
        return 0;
    }
 
  private:
    char op;
    AbstractSyntaxTreePtr right;
};
 
struct MakeUnaryExpression
{
    template <typename, typename> struct result
    {
        typedef UnaryOperator type;
    };
 
    template <typename C, typename R> UnaryOperator operator()(C op, const R &rhs) const
    {
        return UnaryOperator(op, rhs);
    }
};
 
inline phx::function<MakeUnaryExpression> MakeUnary;
 
class Function : public AbstractSyntaxTree
{
  public:
    template <typename F> Function(const std::string &func, const F &param) : func(func), param(Clone(param))
    {
    }
 
    double Eval() const override
    {
        if (func == "sin")
            return sin(param->Eval());
        else if (func == "cos")
            return cos(param->Eval());
        else if (func == "tan")
            return tan(param->Eval());
        else if (func == "exp")
            return exp(param->Eval());
        else if (func == "ln")
            return log(param->Eval());
        else if (func == "sqrt")
            return sqrt(param->Eval());
 
        throw std::invalid_argument("Unknown function");
 
        return 0;
    }
 
    double Eval(const std::unordered_map<std::string, double> &variables) const override
    {
        if (func == "sin")
            return sin(param->Eval(variables));
        else if (func == "cos")
            return cos(param->Eval(variables));
        else if (func == "tan")
            return tan(param->Eval(variables));
        else if (func == "exp")
            return exp(param->Eval(variables));
        else if (func == "ln")
            return log(param->Eval(variables));
        else if (func == "sqrt")
            return sqrt(param->Eval(variables));
 
        throw std::invalid_argument("Unknown function");
 
        return 0;
    }
 
  private:
    std::string func;
    AbstractSyntaxTreePtr param;
};
 
struct MakeFunctionExpression
{
    template <typename, typename, typename> struct result
    {
        typedef Function type;
    };
 
    template <typename Params> Function operator()(const std::string &funcName, const Params &params) const
    {
        return Function(funcName, params);
    }
};
 
inline phx::function<MakeFunctionExpression> MakeFunction;
 
class Expression : public AbstractSyntaxTree
{
  public:
    Expression()
    {
    }
 
    ~Expression() override
    {
    }
 
    template <typename E> Expression(E const &e) : expr(Clone(e))
    {
    }
 
    double Eval() const override
    {
        return expr->Eval();
    }
 
    double Eval(const std::unordered_map<std::string, double> &variables) const override
    {
        return expr->Eval(variables);
    }
 
    friend AbstractSyntaxTreePtr Clone(Expression const &e)
    {
        return e.expr;
    }
 
  private:
    AbstractSyntaxTreePtr expr;
};
} // namespace qasm
 
#endif