yc_node_api.hpp

Go to the documentation of this file.

/*****************************************************************************
 
YASK: Yet Another Stencil Kit
Copyright (c) 2014-2024, Intel Corporation
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to
deal in the Software without restriction, including without limitation the
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
* The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
IN THE SOFTWARE.
 
*****************************************************************************/
 
 
// This file uses Doxygen markup for API documentation-generation.
// See https://www.doxygen.nl/manual/index.html.
#pragma once
 
namespace yask {
 
    // More node types not exposed except via RTTI.
 
    class yc_const_number_node;
    typedef std::shared_ptr<yc_const_number_node> yc_const_number_node_ptr;
 
    class yc_negate_node;
    typedef std::shared_ptr<yc_negate_node> yc_negate_node_ptr;
 
    class yc_commutative_number_node;
    typedef std::shared_ptr<yc_commutative_number_node> yc_commutative_number_node_ptr;
 
    class yc_binary_number_node;
    typedef std::shared_ptr<yc_binary_number_node> yc_binary_number_node_ptr;
 
    class yc_binary_bool_node;
    typedef std::shared_ptr<yc_binary_bool_node> yc_binary_bool_node_ptr;
 
    class yc_binary_comparison_node;
    typedef std::shared_ptr<yc_binary_comparison_node> yc_binary_comparison_node_ptr;
 
    class yc_add_node;
    typedef std::shared_ptr<yc_add_node> yc_add_node_ptr;
 
    class yc_multiply_node;
    typedef std::shared_ptr<yc_multiply_node> yc_multiply_node_ptr;
 
    class yc_subtract_node;
    typedef std::shared_ptr<yc_subtract_node> yc_subtract_node_ptr;
 
    class yc_divide_node;
    typedef std::shared_ptr<yc_divide_node> yc_divide_node_ptr;
 
    class yc_mod_node;
    typedef std::shared_ptr<yc_mod_node> yc_mod_node_ptr;
 
    class yc_not_node;
    typedef std::shared_ptr<yc_not_node> yc_not_node_ptr;
 
    class yc_equals_node;
    typedef std::shared_ptr<yc_equals_node> yc_equals_node_ptr;
 
    class yc_not_equals_node;
    typedef std::shared_ptr<yc_not_equals_node> yc_not_equals_node_ptr;
 
    class yc_less_than_node;
    typedef std::shared_ptr<yc_less_than_node> yc_less_than_node_ptr;
 
    class yc_greater_than_node;
    typedef std::shared_ptr<yc_greater_than_node> yc_greater_than_node_ptr;
 
    class yc_not_less_than_node;
    typedef std::shared_ptr<yc_not_less_than_node> yc_not_less_than_node_ptr;
 
    class yc_not_greater_than_node;
    typedef std::shared_ptr<yc_not_greater_than_node> yc_not_greater_than_node_ptr;
 
    class yc_and_node;
    typedef std::shared_ptr<yc_and_node> yc_and_node_ptr;
 
    class yc_or_node;
    typedef std::shared_ptr<yc_or_node> yc_or_node_ptr;
 
 
    class yc_expr_node {
    public:
        virtual ~yc_expr_node() {}
 
 
        virtual std::string format_simple() const =0;
 
 
        virtual int get_num_nodes() const =0;
    };
 
 
    class yc_equation_node : public virtual yc_expr_node {
    public:
 
 
        virtual yc_var_point_node_ptr get_lhs() =0;
 
 
        virtual yc_number_node_ptr get_rhs() =0;
 
 
        virtual yc_bool_node_ptr get_cond() =0;
 
 
        virtual void set_cond(yc_bool_node_ptr sub_domain_cond ) =0;
 
 
        virtual void set_step_cond(yc_bool_node_ptr step_cond ) =0;
 
        virtual yc_equation_node_ptr clone_ast() const =0;
    };
 
 
    class yc_number_node : public virtual yc_expr_node {
    public:
 
        virtual yc_number_node_ptr clone_ast() const =0;
    };
 
 
    class yc_bool_node : public virtual yc_expr_node {
    public:
 
        virtual yc_bool_node_ptr clone_ast() const =0;
    };
 
 
    class yc_index_node : public virtual yc_number_node {
    public:
 
 
        virtual const std::string&
        get_name() const =0;
    };
 
 
    class yc_var_point_node : public virtual yc_number_node {
    public:
 
 
        virtual yc_var_ptr
        get_var() =0;
 
        YASK_DEPRECATED
        inline yc_var_ptr
        get_grid() {
            return get_var();
        }
    };
 
 
    class yc_const_number_node : public virtual yc_number_node {
    public:
 
 
        virtual void
        set_value(double val  ) =0;
 
 
        virtual double
        get_value() const =0;
    };
 
 
    class yc_negate_node : public virtual yc_number_node {
    public:
 
 
        virtual yc_number_node_ptr
        get_rhs() =0;
    };
 
 
    class yc_commutative_number_node : public virtual yc_number_node {
    public:
 
 
        virtual int
        get_num_operands() =0;
 
 
        virtual std::vector<yc_number_node_ptr>
        get_operands() =0;
 
        virtual void
        add_operand(yc_number_node_ptr node  ) =0;
    };
 
 
    class yc_add_node : public virtual yc_commutative_number_node { };
 
 
    class yc_multiply_node : public virtual yc_commutative_number_node { };
 
 
    class yc_binary_number_node : public virtual yc_number_node {
    public:
 
        virtual yc_number_node_ptr
        get_lhs() =0;
 
        virtual yc_number_node_ptr
        get_rhs() =0;
    };
 
 
    class yc_subtract_node : public virtual yc_binary_number_node { };
 
 
    class yc_divide_node : public virtual yc_binary_number_node { };
 
 
    class yc_mod_node : public virtual yc_binary_number_node { };
 
 
    class yc_not_node : public virtual yc_bool_node {
    public:
 
 
        virtual yc_bool_node_ptr
        get_rhs() =0;
    };
 
    class yc_binary_bool_node : public virtual yc_bool_node {
    public:
 
        virtual yc_bool_node_ptr
        get_lhs() =0;
 
        virtual yc_bool_node_ptr
        get_rhs() =0;
    };
 
 
    class yc_and_node : public virtual yc_binary_bool_node { };
 
 
    class yc_or_node : public virtual yc_binary_bool_node { };
 
    class yc_binary_comparison_node : public virtual yc_bool_node {
    public:
 
 
        virtual yc_number_node_ptr
        get_lhs() =0;
 
 
        virtual yc_number_node_ptr
        get_rhs() =0;
    };
 
 
    class yc_equals_node : public virtual yc_binary_comparison_node { };
 
 
    class yc_not_equals_node : public virtual yc_binary_comparison_node { };
 
 
    class yc_less_than_node : public virtual yc_binary_comparison_node { };
 
 
    class yc_greater_than_node : public virtual yc_binary_comparison_node { };
 
 
    class yc_not_less_than_node : public virtual yc_binary_comparison_node { };
 
 
    class yc_not_greater_than_node : public virtual yc_binary_comparison_node { };
 
    #ifndef SWIG
 
    class yc_number_ptr_arg : public yc_number_node_ptr {
 
    public:
 
        yc_number_ptr_arg(yc_number_node_ptr p) :
            yc_number_node_ptr(p) { }
 
        yc_number_ptr_arg(yc_index_node_ptr p) :
            yc_number_node_ptr(p) { }
 
        yc_number_ptr_arg(yc_var_point_node_ptr p) :
            yc_number_node_ptr(p) { }
    };
 
 
    class yc_number_const_arg : public yc_number_node_ptr {
 
    protected:
        
        yc_number_node_ptr _convert_const(double val) const;
 
    public:
 
        yc_number_const_arg(idx_t i) :
            yc_number_node_ptr(_convert_const(i)) { }
 
        yc_number_const_arg(int i) :
            yc_number_node_ptr(_convert_const(i)) { }
 
        yc_number_const_arg(double f) :
            yc_number_node_ptr(_convert_const(f)) { }
 
        yc_number_const_arg(float f) :
            yc_number_node_ptr(_convert_const(f)) { }
    };
 
 
    class yc_number_any_arg : public yc_number_node_ptr {
 
    protected:
        
        yc_number_node_ptr _convert_const(double val) const;
 
    public:
 
        yc_number_any_arg(yc_number_node_ptr p) :
            yc_number_node_ptr(p) { }
 
        yc_number_any_arg(yc_index_node_ptr p) :
            yc_number_node_ptr(p) { }
 
        yc_number_any_arg(yc_var_point_node_ptr p) :
            yc_number_node_ptr(p) { }
 
        yc_number_any_arg(idx_t i) :
            yc_number_node_ptr(_convert_const(i)) { }
 
        yc_number_any_arg(int i) :
            yc_number_node_ptr(_convert_const(i)) { }
 
        yc_number_any_arg(double f) :
            yc_number_node_ptr(_convert_const(f)) { }
 
        yc_number_any_arg(float f) :
            yc_number_node_ptr(_convert_const(f)) { }
 
        yc_number_any_arg(std::nullptr_t p) :
            yc_number_node_ptr(p) { }
    };
    #endif
    
 
    class yc_node_factory {
    public:
        virtual ~yc_node_factory() {}
 
 
        virtual yc_index_node_ptr
        new_step_index(const std::string& name ) const;
 
 
        virtual yc_index_node_ptr
        new_domain_index(const std::string& name ) const;
 
 
        virtual yc_index_node_ptr
        new_misc_index(const std::string& name ) const;
 
 
        virtual yc_equation_node_ptr
        new_equation_node(yc_var_point_node_ptr lhs,
                          yc_number_node_ptr rhs,
                          yc_bool_node_ptr sub_domain_cond = nullptr ) const;
 
        #ifndef SWIG
 
        virtual yc_number_node_ptr
        new_number_node(yc_number_any_arg arg) const {
            return std::move(arg);
        }
        #endif
        
 
        virtual yc_number_node_ptr
        new_const_number_node(double val ) const;
 
 
        virtual yc_number_node_ptr
        new_const_number_node(idx_t val ) const;
 
 
        virtual yc_number_node_ptr
        new_negate_node(yc_number_node_ptr rhs ) const;
 
 
        virtual yc_number_node_ptr
        new_add_node(yc_number_node_ptr lhs ,
                     yc_number_node_ptr rhs  ) const;
 
 
        virtual yc_number_node_ptr
        new_multiply_node(yc_number_node_ptr lhs ,
                          yc_number_node_ptr rhs  ) const;
 
 
        virtual yc_number_node_ptr
        new_subtract_node(yc_number_node_ptr lhs ,
                          yc_number_node_ptr rhs  ) const;
 
 
        virtual yc_number_node_ptr
        new_divide_node(yc_number_node_ptr lhs ,
                        yc_number_node_ptr rhs  ) const;
 
 
        virtual yc_number_node_ptr
        new_mod_node(yc_number_node_ptr lhs ,
                     yc_number_node_ptr rhs  ) const;
 
 
        virtual yc_index_node_ptr
        new_first_domain_index(yc_index_node_ptr idx ) const;
 
 
        virtual yc_index_node_ptr
        new_last_domain_index(yc_index_node_ptr idx ) const;
 
 
        virtual yc_bool_node_ptr
        new_not_node(yc_bool_node_ptr rhs  ) const;
 
 
        virtual yc_bool_node_ptr
        new_and_node(yc_bool_node_ptr lhs ,
                     yc_bool_node_ptr rhs  ) const;
 
 
        virtual yc_bool_node_ptr
        new_or_node(yc_bool_node_ptr lhs ,
                    yc_bool_node_ptr rhs  ) const;
 
 
        virtual yc_bool_node_ptr
        new_equals_node(yc_number_node_ptr lhs ,
                        yc_number_node_ptr rhs  ) const;
 
 
        virtual yc_bool_node_ptr
        new_not_equals_node(yc_number_node_ptr lhs ,
                            yc_number_node_ptr rhs  ) const;
 
 
        virtual yc_bool_node_ptr
        new_less_than_node(yc_number_node_ptr lhs ,
                           yc_number_node_ptr rhs  ) const;
 
 
        virtual yc_bool_node_ptr
        new_greater_than_node(yc_number_node_ptr lhs ,
                              yc_number_node_ptr rhs  ) const;
 
 
        virtual yc_bool_node_ptr
        new_not_less_than_node(yc_number_node_ptr lhs ,
                               yc_number_node_ptr rhs  ) const;
 
 
        virtual yc_bool_node_ptr
        new_not_greater_than_node(yc_number_node_ptr lhs ,
                                  yc_number_node_ptr rhs  ) const;
 
    };
 
    #define UNARY_MATH_EXPR(fn_name)                                    \
        yc_number_node_ptr fn_name(const yc_number_node_ptr rhs)
 
    UNARY_MATH_EXPR(sqrt);
    UNARY_MATH_EXPR(cbrt);
    UNARY_MATH_EXPR(fabs);
    UNARY_MATH_EXPR(erf);
    UNARY_MATH_EXPR(exp);
    UNARY_MATH_EXPR(log);
    UNARY_MATH_EXPR(sin);
    UNARY_MATH_EXPR(cos);
    UNARY_MATH_EXPR(atan);
    #undef UNARY_MATH_EXPR
 
    #define BINARY_MATH_EXPR(fn_name)                                   \
        yc_number_node_ptr fn_name(const yc_number_node_ptr arg1, const yc_number_node_ptr arg2); \
        yc_number_node_ptr fn_name(double arg1, const yc_number_node_ptr arg2); \
        yc_number_node_ptr fn_name(const yc_number_node_ptr arg1, double arg2)
 
 
    BINARY_MATH_EXPR(pow);
 
 
    BINARY_MATH_EXPR(min);
 
 
 
    BINARY_MATH_EXPR(max);
 
    #undef BINARY_MATH_EXPR
 
    #if !defined SWIG
 
    // Non-class operators.
    // These are not defined for SWIG because
    // the Python operators are defined in the ".i" file.
    // For the binary operators, we define 3 combinations to implicitly
    // avoid the const-const combinations, which conflict with built-in
    // operators on fundamental C++ types, e.g., '5+8'.
 
    yc_number_node_ptr operator-(yc_number_ptr_arg rhs);
 
    yc_number_node_ptr operator+(yc_number_ptr_arg lhs, yc_number_ptr_arg rhs);
    yc_number_node_ptr operator+(yc_number_const_arg lhs, yc_number_ptr_arg rhs);
    yc_number_node_ptr operator+(yc_number_ptr_arg lhs, yc_number_const_arg rhs);
 
    yc_number_node_ptr operator/(yc_number_ptr_arg lhs, yc_number_ptr_arg rhs);
    yc_number_node_ptr operator/(yc_number_const_arg lhs, yc_number_ptr_arg rhs);
    yc_number_node_ptr operator/(yc_number_ptr_arg lhs, yc_number_const_arg rhs);
 
    yc_number_node_ptr operator%(yc_number_ptr_arg lhs, yc_number_ptr_arg rhs);
    yc_number_node_ptr operator%(yc_number_const_arg lhs, yc_number_ptr_arg rhs);
    yc_number_node_ptr operator%(yc_number_ptr_arg lhs, yc_number_const_arg rhs);
 
    yc_number_node_ptr operator*(yc_number_ptr_arg lhs, yc_number_ptr_arg rhs);
    yc_number_node_ptr operator*(yc_number_const_arg lhs, yc_number_ptr_arg rhs);
    yc_number_node_ptr operator*(yc_number_ptr_arg lhs, yc_number_const_arg rhs);
 
    yc_number_node_ptr operator-(yc_number_ptr_arg lhs, yc_number_ptr_arg rhs);
    yc_number_node_ptr operator-(yc_number_const_arg lhs, yc_number_ptr_arg rhs);
    yc_number_node_ptr operator-(yc_number_ptr_arg lhs, yc_number_const_arg rhs);
 
    void operator+=(yc_number_node_ptr& lhs, yc_number_node_ptr rhs);
    void operator+=(yc_number_node_ptr& lhs, yc_number_const_arg rhs);
 
    void operator-=(yc_number_node_ptr& lhs, yc_number_node_ptr rhs);
    void operator-=(yc_number_node_ptr& lhs, yc_number_const_arg rhs);
 
    void operator*=(yc_number_node_ptr& lhs, yc_number_node_ptr rhs);
    void operator*=(yc_number_node_ptr& lhs, yc_number_const_arg rhs);
 
    void operator/=(yc_number_node_ptr& lhs, yc_number_node_ptr rhs);
    void operator/=(yc_number_node_ptr& lhs, yc_number_const_arg rhs);
 
 
    yc_bool_node_ptr operator!(yc_bool_node_ptr rhs);
 
 
    yc_bool_node_ptr operator||(yc_bool_node_ptr lhs, yc_bool_node_ptr rhs);
 
 
    yc_bool_node_ptr operator&&(yc_bool_node_ptr lhs, yc_bool_node_ptr rhs);
 
 
    #define BOOL_OPER(oper, fn)                                         \
        inline yc_bool_node_ptr operator oper(const yc_number_node_ptr lhs, const yc_number_node_ptr rhs) { \
            yc_node_factory nfac; return nfac.fn(lhs, rhs); }           \
        inline yc_bool_node_ptr operator oper(const yc_number_node_ptr lhs, const yc_index_node_ptr rhs) { \
            yc_node_factory nfac; return nfac.fn(lhs, rhs); }           \
        inline yc_bool_node_ptr operator oper(const yc_number_node_ptr lhs, const yc_var_point_node_ptr rhs) { \
            yc_node_factory nfac; return nfac.fn(lhs, rhs); }           \
        inline yc_bool_node_ptr operator oper(const yc_index_node_ptr lhs, const yc_number_node_ptr rhs) { \
            yc_node_factory nfac; return nfac.fn(lhs, rhs); }           \
        inline yc_bool_node_ptr operator oper(const yc_index_node_ptr lhs, const yc_index_node_ptr rhs) { \
            yc_node_factory nfac; return nfac.fn(lhs, rhs); }           \
        inline yc_bool_node_ptr operator oper(const yc_index_node_ptr lhs, const yc_var_point_node_ptr rhs) { \
            yc_node_factory nfac; return nfac.fn(lhs, rhs); }           \
        inline yc_bool_node_ptr operator oper(const yc_var_point_node_ptr lhs, const yc_number_node_ptr rhs) { \
            yc_node_factory nfac; return nfac.fn(lhs, rhs); }           \
        inline yc_bool_node_ptr operator oper(const yc_var_point_node_ptr lhs, const yc_index_node_ptr rhs) { \
            yc_node_factory nfac; return nfac.fn(lhs, rhs); }           \
        inline yc_bool_node_ptr operator oper(const yc_var_point_node_ptr lhs, const yc_var_point_node_ptr rhs) { \
            yc_node_factory nfac; return nfac.fn(lhs, rhs); }           \
        inline yc_bool_node_ptr operator oper(const yc_number_node_ptr lhs, double rhs) { \
            yc_node_factory nfac; return nfac.fn(lhs, nfac.new_number_node(rhs)); } \
        inline yc_bool_node_ptr operator oper(const yc_index_node_ptr lhs, double rhs) { \
            yc_node_factory nfac; return nfac.fn(lhs, nfac.new_number_node(rhs)); } \
        inline yc_bool_node_ptr operator oper(const yc_var_point_node_ptr lhs, double rhs) { \
            yc_node_factory nfac; return nfac.fn(lhs, nfac.new_number_node(rhs)); }
 
    BOOL_OPER(==, new_equals_node)
    BOOL_OPER(!=, new_not_equals_node)
    BOOL_OPER(<, new_less_than_node)
    BOOL_OPER(>, new_greater_than_node)
    BOOL_OPER(<=, new_not_greater_than_node)
    BOOL_OPER(>=, new_not_less_than_node)
    #undef BOOL_OPER
 
 
    #define EQUALS <<
 
    yc_equation_node_ptr operator EQUALS(yc_var_point_node_ptr gpp, const yc_number_any_arg rhs);
 
 
    #define IF_DOMAIN ^=
 
    yc_equation_node_ptr operator IF_DOMAIN(yc_equation_node_ptr expr,
                                            const yc_bool_node_ptr cond);
 
 
    #define IF_STEP |=
 
    yc_equation_node_ptr operator IF_STEP(yc_equation_node_ptr expr,
                                          const yc_bool_node_ptr cond);
 
    #endif  // !SWIG.
 
} // namespace yask.