symbolic.h

Go to the documentation of this file.

 
#pragma once
 
#include <symengine/add.h>
#include <symengine/basic.h>
#include <symengine/dict.h>
#include <symengine/integer.h>
#include <symengine/logic.h>
#include <symengine/mul.h>
#include <symengine/nan.h>
#include <symengine/real_double.h>
#include <symengine/simplify.h>
#include <symengine/symbol.h>
 
#include <unordered_map>
#include "symengine/functions.h"
#include "symengine/subs.h"
 
namespace sdfg {
 
namespace types {
// forward declaration, because it depends on contents of this file
class IType;
} // namespace types
 
namespace symbolic {


typedef SymEngine::RCP<const SymEngine::Symbol> Symbol;

typedef SymEngine::RCP<const SymEngine::Number> Number;

typedef SymEngine::RCP<const SymEngine::Integer> Integer;

typedef SymEngine::RCP<const SymEngine::Infty> Infty;

typedef SymEngine::RCP<const SymEngine::Basic> Expression;

typedef SymEngine::RCP<const SymEngine::Boolean> Condition;

typedef std::vector<Expression> MultiExpression;

typedef std::vector<Symbol> SymbolVec;

typedef std::set<Symbol, SymEngine::RCPBasicKeyLess> SymbolSet;

typedef std::unordered_map<Symbol, Expression, SymEngine::RCPBasicHash, SymEngine::RCPBasicKeyEq> SymbolMap;

typedef std::vector<Symbol> ExpressionVec;

typedef std::set<Expression, SymEngine::RCPBasicKeyLess> ExpressionSet;

typedef std::unordered_map<Expression, Expression, SymEngine::RCPBasicHash, SymEngine::RCPBasicKeyEq> ExpressionMap;
 
typedef SymEngine::map_basic_basic ExpressionMapping;
 // end of symbolic_types group


Symbol symbol(const std::string& name);

Integer integer(int64_t value);

Integer zero();

Integer one();

Condition __false__();

Condition __true__();

Symbol __nullptr__();

bool is_nullptr(const Symbol symbol);

bool is_nullptr(const std::string& name);

bool is_pointer(const Symbol symbol);

bool is_nv(const Symbol symbol);
 // end of symbolic_creation group


Condition And(const Condition lhs, const Condition rhs);

Condition Or(const Condition lhs, const Condition rhs);

Condition Not(const Condition expr);

bool is_true(const Expression expr);

bool is_false(const Expression expr);
 // end of symbolic_logic group


Expression add(const Expression lhs, const Expression rhs);

Expression sub(const Expression lhs, const Expression rhs);

Expression mul(const Expression lhs, const Expression rhs);

Expression div(const Expression lhs, const Expression rhs);

Expression floor_div(const Expression lhs, const Expression divisor);

Expression ceil_div(const Expression dividend, const Expression divisor);

Expression ceil_count(const Expression extent, const Expression chunk);

Expression min(const Expression lhs, const Expression rhs);

Expression max(const Expression lhs, const Expression rhs);

Expression abs(const Expression expr);

Expression mod(const Expression lhs, const Expression rhs);

Expression bit_xor(const Expression lhs, const Expression rhs);

class IModFunction : public SymEngine::FunctionSymbol {
public:
    IModFunction(const Expression lhs, const Expression rhs) : FunctionSymbol("imod", {lhs, rhs}) {
    }
};

Expression pow(const Expression base, const Expression exp);

Expression zext_i64(const Expression expr);

class ZExtI64Function : public SymEngine::FunctionSymbol {
public:
    explicit ZExtI64Function(const Expression expr) : FunctionSymbol("zext_i64", expr) {
    }
};

Expression trunc_i32(const Expression expr);

class TruncI32Function : public SymEngine::FunctionSymbol {
public:
    explicit TruncI32Function(const Expression expr) : FunctionSymbol("trunc_i32", expr) {
    }
};
 // end of symbolic_arithmetic group


Expression size_of_type(const types::IType& type);

class SizeOfTypeFunction : public SymEngine::FunctionSymbol {
private:
    const types::IType& type_;
 
public:
    explicit SizeOfTypeFunction(const types::IType& type)
        : FunctionSymbol("sizeof", SymEngine::vec_basic{}), type_(type) {
    }
 
    const types::IType& get_type() const {
        return type_;
    }
};

Expression dynamic_sizeof(const Symbol symbol);

class DynamicSizeOfFunction : public SymEngine::FunctionSymbol {
public:
    explicit DynamicSizeOfFunction(const Symbol symbol) : FunctionSymbol("dynamic_sizeof", symbol) {
    }
};

Expression malloc_usable_size(const Symbol symbol);

class MallocUsableSizeFunction : public SymEngine::FunctionSymbol {
public:
    explicit MallocUsableSizeFunction(const Symbol symbol) : FunctionSymbol("malloc_usable_size", symbol) {
    }
};
 // end of symbolic_sizeof group


Condition Eq(const Expression lhs, const Expression rhs);

Condition Ne(const Expression lhs, const Expression rhs);

Condition Lt(const Expression lhs, const Expression rhs);

Condition Gt(const Expression lhs, const Expression rhs);

Condition Le(const Expression lhs, const Expression rhs);

Condition Ge(const Expression lhs, const Expression rhs);
 // end of symbolic_comparison group


Expression expand(const Expression expr);

Expression factor(const Expression expr);

Expression simplify(const Expression expr);

Expression overapproximate(const Expression expr);

bool eq(const Expression lhs, const Expression rhs);

bool null_safe_eq(const Expression lhs, const Expression rhs);

bool uses(const Expression expr, const Symbol sym);

bool uses(const Expression expr, const std::string& name);

SymbolSet atoms(const Expression expr);

template<typename T>
inline bool has(const Expression expr) {
    for (auto& atom : SymEngine::atoms<T>(*expr)) {
        if (SymEngine::is_a<T>(*atom)) {
            return true;
        }
    }
    return false;
}

template<typename T>
inline ExpressionSet find(const Expression expr) {
    ExpressionSet res;
    for (auto& atom : SymEngine::atoms<T>(*expr)) {
        if (SymEngine::is_a<T>(*atom)) {
            res.insert(atom);
        }
    }
    return res;
}

bool has_dynamic_sizeof(const Expression expr);

ExpressionSet muls(const Expression expr);

Expression subs(const Expression expr, const Expression old_expr, const Expression new_expr);

inline Expression subs(const Expression expr, const symbolic::ExpressionMapping& replacements) {
    return SymEngine::subs(expr, replacements);
}

Condition subs(const Condition expr, const Expression old_expr, const Expression new_expr);

Condition subs(const Condition expr, const symbolic::ExpressionMapping& replacements);
 
bool substitute(ExpressionSet& set, const symbolic::ExpressionMapping& replacements);
 
MultiExpression substitute(const MultiExpression& vec, const symbolic::ExpressionMapping& replacements);

Expression inverse(const Expression expr, const Symbol symbol);
 // end of symbolic_manipulation group


Symbol threadIdx_x();

Symbol threadIdx_y();

Symbol threadIdx_z();

Symbol blockDim_x();

Symbol blockDim_y();

Symbol blockDim_z();

Symbol blockIdx_x();

Symbol blockIdx_y();

Symbol blockIdx_z();

Symbol gridDim_x();

Symbol gridDim_y();

Symbol gridDim_z();
 // end of symbolic_gpu group


Expression parse(const std::string& expr_str);
 // end of symbolic_parsing group
 
} // namespace symbolic
} // namespace sdfg