@lakutata/math 0.0.0-stage → 3.1.3

package/vendor/symengine/symengine/as_real_imag.cpp

@@ -0,0 +1,289 @@
+#include <symengine/visitor.h>
+#include <symengine/basic.h>
+
+namespace SymEngine
+{
+
+void pow_number(const RCP<const Basic> &in_re, const RCP<const Basic> &in_im,
+                unsigned long n, Ptr<RCP<const Basic>> &out_re,
+                Ptr<RCP<const Basic>> &out_im)
+{
+    unsigned long mask = 1;
+    RCP<const Basic> tmp;
+    RCP<const Basic> p_re = in_re;
+    RCP<const Basic> p_im = in_im;
+    *out_re = one;
+    *out_im = zero;
+
+    while (true) {
+        if (n & mask) {
+            // Multiply r by p
+            tmp = sub(mul(*out_re, p_re), mul(*out_im, p_im));
+            *out_im = add(mul(*out_re, p_im), mul(*out_im, p_re));
+            *out_re = tmp;
+        }
+        mask = mask << 1;
+        if (mask > 0 and n >= mask) {
+            // Multiply p by p
+            tmp = sub(mul(p_re, p_re), mul(p_im, p_im));
+            p_im = mul(two, mul(p_re, p_im));
+            p_re = tmp;
+        } else {
+            break;
+        }
+    }
+}
+
+class RealImagVisitor : public BaseVisitor<RealImagVisitor>
+{
+private:
+    Ptr<RCP<const Basic>> real_, imag_;
+
+public:
+    RealImagVisitor(const Ptr<RCP<const Basic>> &real,
+                    const Ptr<RCP<const Basic>> &imag)
+        : real_{real}, imag_{imag}
+    {
+    }
+
+    void apply(const Basic &b)
+    {
+        b.accept(*this);
+    }
+
+    void bvisit(const Mul &x)
+    {
+        RCP<const Basic> rest = one;
+        RCP<const Basic> fre_ = one, fim_ = zero;
+
+        for (const auto &arg : x.get_args()) {
+            apply(*arg);
+            std::tie(fre_, fim_)
+                = std::make_tuple(sub(mul(fre_, *real_), mul(fim_, *imag_)),
+                                  add(mul(fre_, *imag_), mul(fim_, *real_)));
+        }
+        *real_ = fre_;
+        *imag_ = fim_;
+    }
+
+    void bvisit(const Add &x)
+    {
+        RCP<const Basic> t;
+        umap_basic_num dr, dim;
+        RCP<const Number> coefr = zero, coefim = zero, coef;
+
+        for (const auto &arg : x.get_args()) {
+            apply(*arg);
+            if (is_a_Number(**real_)) {
+                iaddnum(outArg(coefr), rcp_static_cast<const Number>(*real_));
+            } else {
+                Add::as_coef_term(*real_, outArg(coef), outArg(t));
+                Add::dict_add_term(dr, coef, t);
+            }
+            if (is_a_Number(**imag_)) {
+                iaddnum(outArg(coefim), rcp_static_cast<const Number>(*imag_));
+            } else {
+                Add::as_coef_term(*imag_, outArg(coef), outArg(t));
+                Add::dict_add_term(dim, coef, t);
+            }
+        }
+
+        *real_ = Add::from_dict(coefr, std::move(dr));
+        *imag_ = Add::from_dict(coefim, std::move(dim));
+    }
+
+    void bvisit(const Pow &x)
+    {
+        RCP<const Basic> exp_;
+        exp_ = x.get_exp();
+        apply(*x.get_base());
+
+        if (eq(**imag_, *zero)) {
+            *real_ = x.rcp_from_this();
+            *imag_ = zero;
+            return;
+        }
+        if (is_a<Integer>(*exp_)) {
+            if (static_cast<const Integer &>(*exp_).is_negative()) {
+                auto magn = add(mul(*real_, *real_), mul(*imag_, *imag_));
+                *imag_ = neg(*imag_);
+                RCP<const Integer> expx = rcp_static_cast<const Integer>(exp_);
+                expx = static_cast<const Integer &>(*exp_).neg();
+                unsigned long n = numeric_cast<unsigned long>(
+                    mp_get_ui(expx->as_integer_class()));
+                RCP<const Basic> real1 = *real_, imag1 = *imag_;
+                pow_number(real1, imag1, n, real_, imag_);
+                magn = pow(magn, expx);
+                *real_ = div(*real_, magn);
+                *imag_ = div(*imag_, magn);
+            } else {
+                RCP<const Integer> expx = rcp_static_cast<const Integer>(exp_);
+                unsigned long n = numeric_cast<unsigned long>(
+                    mp_get_ui(expx->as_integer_class()));
+                RCP<const Basic> real1 = *real_, imag1 = *imag_;
+                pow_number(real1, imag1, n, real_, imag_);
+            }
+        } else if (is_a<Rational>(*exp_)) {
+            auto magn = sqrt(add(mul(*real_, *real_), mul(*imag_, *imag_)));
+            auto ang = atan2(*imag_, *real_);
+            magn = pow(magn, exp_);
+            ang = mul(ang, exp_);
+            *real_ = mul(magn, cos(ang));
+            *imag_ = mul(magn, sin(ang));
+        } else {
+            throw SymEngineException("Not Implemented");
+        }
+    }
+
+    void bvisit(const ComplexBase &x)
+    {
+        *real_ = x.real_part();
+        *imag_ = x.imaginary_part();
+    }
+
+    void bvisit(const Infty &x)
+    {
+        if (eq(x, *ComplexInf)) {
+            *real_ = Nan;
+            *imag_ = Nan;
+        } else {
+            *real_ = x.rcp_from_this();
+            *imag_ = zero;
+        }
+    }
+
+    void bvisit(const Sin &x)
+    {
+        apply(*x.get_arg());
+        std::tie(*real_, *imag_) = std::make_tuple(
+            mul(sin(*real_), cosh(*imag_)), mul(sinh(*imag_), cos(*real_)));
+    }
+
+    void bvisit(const Cos &x)
+    {
+        apply(*x.get_arg());
+        std::tie(*real_, *imag_)
+            = std::make_tuple(mul(cos(*real_), cosh(*imag_)),
+                              neg(mul(sinh(*imag_), sin(*real_))));
+    }
+
+    void bvisit(const Tan &x)
+    {
+        apply(*x.get_arg());
+        if (eq(**imag_, *zero)) {
+            *real_ = x.rcp_from_this();
+            *imag_ = zero;
+            return;
+        }
+        auto twice_real_ = mul(two, *real_), twice_imag_ = mul(two, *imag_);
+        auto den = add(cos(twice_real_), cosh(twice_imag_));
+        *real_ = div(sin(twice_real_), den);
+        *imag_ = div(sinh(twice_imag_), den);
+    }
+
+    void bvisit(const Csc &x)
+    {
+        apply(*div(one, sin(x.get_arg())));
+    }
+
+    void bvisit(const Sec &x)
+    {
+        apply(*div(one, cos(x.get_arg())));
+    }
+
+    void bvisit(const Cot &x)
+    {
+        apply(*x.get_arg());
+        if (eq(**imag_, *zero)) {
+            *real_ = x.rcp_from_this();
+            return;
+        }
+        auto twice_real_ = mul(two, *real_), twice_imag_ = mul(two, *imag_);
+        auto den = sub(cos(twice_real_), cosh(twice_imag_));
+        *real_ = neg(div(sin(twice_real_), den));
+        *imag_ = neg(div(sinh(twice_imag_), den));
+    }
+
+    void bvisit(const Sinh &x)
+    {
+        apply(*x.get_arg());
+        std::tie(*real_, *imag_) = std::make_tuple(
+            mul(sinh(*real_), cos(*imag_)), mul(sin(*imag_), cosh(*real_)));
+    }
+
+    void bvisit(const Cosh &x)
+    {
+        apply(*x.get_arg());
+        std::tie(*real_, *imag_) = std::make_tuple(
+            mul(cosh(*real_), cos(*imag_)), mul(sin(*imag_), sinh(*real_)));
+    }
+
+    void bvisit(const Tanh &x)
+    {
+        apply(*x.get_arg());
+        if (eq(**imag_, *zero)) {
+            *real_ = x.rcp_from_this();
+            return;
+        }
+        auto sinh_re = sinh(*real_), cos_im = cos(*imag_);
+        auto den = add(pow(sinh_re, two), pow(cos_im, two));
+        *real_ = div(mul(sinh_re, cosh(*real_)), den);
+        *imag_ = div(mul(sin(*imag_), cos_im), den);
+    }
+
+    void bvisit(const Csch &x)
+    {
+        apply(*div(one, sinh(x.get_arg())));
+    }
+
+    void bvisit(const Sech &x)
+    {
+        apply(*div(one, cosh(x.get_arg())));
+    }
+
+    void bvisit(const Coth &x)
+    {
+        apply(*x.get_arg());
+        if (eq(**imag_, *zero)) {
+            *real_ = x.rcp_from_this();
+            return;
+        }
+        auto sinh_re = sinh(*real_), sin_im = sin(*imag_);
+        auto den = add(pow(sinh_re, two), pow(sin_im, two));
+        *real_ = div(mul(sinh_re, cosh(*real_)), den);
+        *imag_ = neg(div(mul(sin_im, cos(*imag_)), den));
+    }
+
+    void bvisit(const Abs &x)
+    {
+        *real_ = x.rcp_from_this();
+        *imag_ = zero;
+    }
+
+    void bvisit(const Function &x)
+    {
+        throw SymEngineException(
+            "Not Implemented classes for real and imaginary parts");
+    }
+
+    void bvisit(const Symbol &x)
+    {
+        throw SymEngineException(
+            "Not Implemented classes for real and imaginary parts");
+    }
+
+    void bvisit(const Basic &x)
+    {
+        *real_ = x.rcp_from_this();
+        *imag_ = zero;
+    }
+};
+
+void as_real_imag(const RCP<const Basic> &x, const Ptr<RCP<const Basic>> &real,
+                  const Ptr<RCP<const Basic>> &imag)
+{
+    RealImagVisitor v(real, imag);
+    v.apply(*x);
+}
+
+} // namespace SymEngine

package/vendor/symengine/symengine/assumptions.cpp

@@ -0,0 +1,202 @@
+#include <symengine/logic.h>
+#include <symengine/assumptions.h>
+#include <symengine/number.h>
+
+namespace SymEngine
+{
+
+Assumptions::Assumptions(const set_basic &statements)
+{
+    // Convert a set of statements into a faster and easier internal form
+    for (const auto &s : statements) {
+        if (is_a<Contains>(*s)) {
+            const Contains &contains = down_cast<const Contains &>(*s);
+            const auto expr = contains.get_expr();
+            const auto set = contains.get_set();
+            if (is_a<Symbol>(*expr)) {
+                if (is_a<Complexes>(*set)) {
+                    complex_symbols_.insert(expr);
+                } else if (is_a<Reals>(*set)) {
+                    complex_symbols_.insert(expr);
+                    real_symbols_.insert(expr);
+                } else if (is_a<Rationals>(*set)) {
+                    complex_symbols_.insert(expr);
+                    real_symbols_.insert(expr);
+                    rational_symbols_.insert(expr);
+                } else if (is_a<Integers>(*set)) {
+                    complex_symbols_.insert(expr);
+                    real_symbols_.insert(expr);
+                    rational_symbols_.insert(expr);
+                    integer_symbols_.insert(expr);
+                }
+            }
+        } else if (is_a<LessThan>(*s)) {
+            const LessThan &less_than = down_cast<const LessThan &>(*s);
+            const auto &arg1 = less_than.get_arg1();
+            const auto &arg2 = less_than.get_arg2();
+            if (is_a<Symbol>(*arg2) and is_a_Number(*arg1)) {
+                real_symbols_.insert(arg2);
+                if (down_cast<const Number &>(*arg1).is_positive()) {
+                    set_map(nonnegative_, arg2, true);
+                    set_map(positive_, arg2, true);
+                    set_map(negative_, arg2, false);
+                    set_map(nonpositive_, arg2, false);
+                    set_map(nonzero_, arg2, true);
+                    set_map(zero_, arg2, false);
+                } else if (down_cast<const Number &>(*arg1).is_zero()) {
+                    set_map(nonnegative_, arg2, true);
+                    set_map(negative_, arg2, false);
+                }
+            } else if (is_a<Symbol>(*arg1) and is_a_Number(*arg2)) {
+                real_symbols_.insert(arg1);
+                if (down_cast<const Number &>(*arg2).is_negative()) {
+                    set_map(nonnegative_, arg1, false);
+                    set_map(positive_, arg1, false);
+                    set_map(negative_, arg1, true);
+                    set_map(nonpositive_, arg1, true);
+                    set_map(nonzero_, arg1, true);
+                    set_map(zero_, arg1, false);
+                } else if (down_cast<const Number &>(*arg2).is_zero()) {
+                    set_map(nonpositive_, arg1, true);
+                    set_map(positive_, arg1, false);
+                }
+            }
+        } else if (is_a<StrictLessThan>(*s)) {
+            const StrictLessThan &strictly_less_than
+                = down_cast<const StrictLessThan &>(*s);
+            const auto arg1 = strictly_less_than.get_arg1();
+            const auto arg2 = strictly_less_than.get_arg2();
+            if (is_a<Symbol>(*arg2) and is_a_Number(*arg1)) {
+                real_symbols_.insert(arg2);
+                if (not down_cast<const Number &>(*arg1).is_negative()) {
+                    set_map(nonnegative_, arg2, true);
+                    set_map(positive_, arg2, true);
+                    set_map(negative_, arg2, false);
+                    set_map(nonpositive_, arg2, false);
+                    set_map(nonzero_, arg2, true);
+                    set_map(zero_, arg2, false);
+                }
+            } else if (is_a<Symbol>(*arg1) and is_a_Number(*arg2)) {
+                real_symbols_.insert(arg1);
+                if (not down_cast<const Number &>(*arg2).is_positive()) {
+                    set_map(nonnegative_, arg1, false);
+                    set_map(positive_, arg1, false);
+                    set_map(negative_, arg1, true);
+                    set_map(nonpositive_, arg1, true);
+                    set_map(nonzero_, arg1, true);
+                    set_map(zero_, arg1, false);
+                }
+            }
+        } else if (is_a<Equality>(*s)) {
+            const Equality &equals = down_cast<const Equality &>(*s);
+            const auto arg1 = equals.get_arg1();
+            const auto arg2 = equals.get_arg2();
+            if (is_a_Number(*arg1) and is_a<Symbol>(*arg2)) {
+                complex_symbols_.insert(arg2);
+                if (down_cast<const Number &>(*arg1).is_zero()) {
+                    set_map(zero_, arg2, true);
+                    real_symbols_.insert(arg2);
+                    rational_symbols_.insert(arg2);
+                    integer_symbols_.insert(arg2);
+                    set_map(positive_, arg2, false);
+                    set_map(negative_, arg2, false);
+                    set_map(nonpositive_, arg2, true);
+                    set_map(nonnegative_, arg2, true);
+                    set_map(nonzero_, arg2, false);
+                } else {
+                    set_map(zero_, arg2, false);
+                    set_map(nonzero_, arg2, true);
+                }
+            }
+        } else if (is_a<Unequality>(*s)) {
+            const Unequality &uneq = down_cast<const Unequality &>(*s);
+            const auto arg1 = uneq.get_arg1();
+            const auto arg2 = uneq.get_arg2();
+            if (is_a_Number(*arg1) and is_a<Symbol>(*arg2)) {
+                if (down_cast<const Number &>(*arg1).is_zero()) {
+                    set_map(zero_, arg2, false);
+                    set_map(nonzero_, arg2, true);
+                }
+            }
+        }
+    }
+}
+
+void Assumptions::set_map(umap_basic_bool &map, const RCP<const Basic> &symbol,
+                          bool value)
+{
+    // Set element in map to true or false. Check for consistency within map
+    tribool old_value = from_map(map, symbol);
+    if ((is_true(old_value) and not value) or (is_false(old_value) and value)) {
+        throw SymEngineException("Symbol " + symbol->__str__()
+                                 + " have inconsistent positive/negativeness");
+    }
+    map[symbol] = value;
+}
+
+tribool Assumptions::from_map(const umap_basic_bool &map,
+                              const RCP<const Basic> &symbol) const
+{
+    auto it = map.find(symbol);
+    if (it != map.end()) {
+        return (tribool)((*it).second);
+    } else {
+        return tribool::indeterminate;
+    }
+}
+
+tribool Assumptions::is_complex(const RCP<const Basic> &symbol) const
+{
+    bool cmplx = complex_symbols_.find(symbol) != complex_symbols_.end();
+    return cmplx ? tribool::tritrue : tribool::indeterminate;
+}
+
+tribool Assumptions::is_real(const RCP<const Basic> &symbol) const
+{
+    bool real = real_symbols_.find(symbol) != real_symbols_.end();
+    return real ? tribool::tritrue : tribool::indeterminate;
+}
+
+tribool Assumptions::is_rational(const RCP<const Basic> &symbol) const
+{
+    bool rational = rational_symbols_.find(symbol) != rational_symbols_.end();
+    return rational ? tribool::tritrue : tribool::indeterminate;
+}
+
+tribool Assumptions::is_integer(const RCP<const Basic> &symbol) const
+{
+    bool integer = integer_symbols_.find(symbol) != integer_symbols_.end();
+    return integer ? tribool::tritrue : tribool::indeterminate;
+}
+
+tribool Assumptions::is_positive(const RCP<const Basic> &symbol) const
+{
+    return from_map(positive_, symbol);
+}
+
+tribool Assumptions::is_nonnegative(const RCP<const Basic> &symbol) const
+{
+    return from_map(nonnegative_, symbol);
+}
+
+tribool Assumptions::is_negative(const RCP<const Basic> &symbol) const
+{
+    return from_map(negative_, symbol);
+}
+
+tribool Assumptions::is_nonpositive(const RCP<const Basic> &symbol) const
+{
+    return from_map(nonpositive_, symbol);
+}
+
+tribool Assumptions::is_nonzero(const RCP<const Basic> &symbol) const
+{
+    return from_map(nonzero_, symbol);
+}
+
+tribool Assumptions::is_zero(const RCP<const Basic> &symbol) const
+{
+    return from_map(zero_, symbol);
+}
+
+} // namespace SymEngine

package/vendor/symengine/symengine/assumptions.h

@@ -0,0 +1,47 @@
+#ifndef SYMENGINE_ASSUMPTIONS_H
+#define SYMENGINE_ASSUMPTIONS_H
+
+#include <symengine/dict.h>
+#include <symengine/basic.h>
+
+namespace SymEngine
+{
+
+typedef std::unordered_map<RCP<const Basic>, bool, RCPBasicHash, RCPBasicKeyEq>
+    umap_basic_bool;
+
+class SYMENGINE_EXPORT Assumptions
+{
+private:
+    set_basic complex_symbols_;
+    set_basic real_symbols_;
+    set_basic rational_symbols_;
+    set_basic integer_symbols_;
+    umap_basic_bool positive_;
+    umap_basic_bool nonnegative_;
+    umap_basic_bool negative_;
+    umap_basic_bool nonpositive_;
+    umap_basic_bool nonzero_;
+    umap_basic_bool zero_;
+
+    void set_map(umap_basic_bool &map, const RCP<const Basic> &symbol,
+                 bool value);
+    tribool from_map(const umap_basic_bool &map,
+                     const RCP<const Basic> &symbol) const;
+
+public:
+    Assumptions(const set_basic &statements);
+    tribool is_complex(const RCP<const Basic> &symbol) const;
+    tribool is_real(const RCP<const Basic> &symbol) const;
+    tribool is_rational(const RCP<const Basic> &symbol) const;
+    tribool is_integer(const RCP<const Basic> &symbol) const;
+    tribool is_positive(const RCP<const Basic> &symbol) const;
+    tribool is_nonnegative(const RCP<const Basic> &symbol) const;
+    tribool is_negative(const RCP<const Basic> &symbol) const;
+    tribool is_nonpositive(const RCP<const Basic> &symbol) const;
+    tribool is_nonzero(const RCP<const Basic> &symbol) const;
+    tribool is_zero(const RCP<const Basic> &symbol) const;
+};
+} // namespace SymEngine
+
+#endif // SYMENGINE_ASSUMPTIONS_H

package/vendor/symengine/symengine/basic-inl.h

@@ -0,0 +1,152 @@
+#ifndef SYMENGINE_BASIC_INL_H
+#define SYMENGINE_BASIC_INL_H
+
+namespace SymEngine
+{
+
+inline hash_t Basic::hash() const
+{
+    if (hash_ == 0)
+        hash_ = __hash__();
+    return hash_;
+}
+
+//! \return true if not equal
+inline bool Basic::__neq__(const Basic &o) const
+{
+    return not(eq(*this, o));
+}
+
+//! \return true if  `a` equal `b`
+inline bool eq(const Basic &a, const Basic &b)
+{
+    if (&a == &b) {
+        return true;
+    }
+    return a.__eq__(b);
+}
+//! \return true if  `a` not equal `b`
+inline bool neq(const Basic &a, const Basic &b)
+{
+    return not(a.__eq__(b));
+}
+
+//! Templatised version to check is_a type
+template <class T>
+inline bool is_a(const Basic &b)
+{
+    return T::type_code_id == b.get_type_code();
+}
+
+#if HAVE_SYMENGINE_RTTI
+template <class T>
+inline bool is_a_sub(const Basic &b)
+{
+    return dynamic_cast<const T *>(&b) != nullptr;
+}
+#endif
+
+inline bool is_same_type(const Basic &a, const Basic &b)
+{
+    return a.get_type_code() == b.get_type_code();
+}
+
+//! `<<` Operator
+inline std::ostream &operator<<(std::ostream &out, const SymEngine::Basic &p)
+{
+    out << p.__str__();
+    return out;
+}
+
+//! Templatised version to combine hash
+template <typename T>
+inline void hash_combine_impl(
+    hash_t &seed, const T &v,
+    typename std::enable_if<std::is_base_of<Basic, T>::value>::type * = nullptr)
+{
+    hash_combine(seed, v.hash());
+}
+
+template <typename T>
+inline void hash_combine_impl(
+    hash_t &seed, const T &v,
+    typename std::enable_if<std::is_integral<T>::value>::type * = nullptr)
+{
+    seed ^= hash_t(v) + hash_t(0x9e3779b9) + (seed << 6) + (seed >> 2);
+}
+
+inline void hash_combine_impl(hash_t &seed, const std::string &s)
+{
+    for (const char &c : s) {
+        hash_combine<hash_t>(seed, static_cast<hash_t>(c));
+    }
+}
+
+inline void hash_combine_impl(hash_t &seed, const double &s)
+{
+    union {
+        hash_t h;
+        double d;
+    } u;
+    u.h = 0u;
+    u.d = s;
+    hash_combine(seed, u.h);
+}
+
+template <class T>
+inline void hash_combine(hash_t &seed, const T &v)
+{
+    hash_combine_impl(seed, v);
+}
+
+template <typename T>
+hash_t vec_hash<T>::operator()(const T &v) const
+{
+    hash_t h = 0;
+    for (auto i : v)
+        hash_combine<typename T::value_type>(h, i);
+    return h;
+}
+
+//! workaround for MinGW bug
+template <typename T>
+std::string to_string(const T &value)
+{
+#ifdef HAVE_SYMENGINE_STD_TO_STRING
+    return std::to_string(value);
+#else
+    std::ostringstream ss;
+    ss << value;
+    return ss.str();
+#endif
+}
+
+struct SYMENGINE_EXPORT ConstantInitializer {
+    ConstantInitializer();
+    ~ConstantInitializer();
+};
+
+inline bool _symengine_init_constants()
+{
+    static ConstantInitializer ci;
+    return true;
+}
+
+static bool _symengine_constants_initialized = _symengine_init_constants();
+
+} // namespace SymEngine
+
+// std namespace functions
+namespace std
+{
+//! Specialise std::hash for Basic. We just call Basic.__hash__()
+template <>
+struct hash<SymEngine::Basic> {
+    std::size_t operator()(const SymEngine::Basic &b) const
+    {
+        return static_cast<std::size_t>(b.hash());
+    }
+};
+} // namespace std
+
+#endif

package/vendor/symengine/symengine/basic-methods.inc

@@ -0,0 +1,9 @@
+class EvalRealDoubleVisitorFinal;
+
+#define SYMENGINE_INCLUDE_METHODS_BASE()                                       \
+    virtual void accept(Visitor &v) const = 0;                                 \
+    virtual void accept(EvalRealDoubleVisitorFinal &v) const = 0;
+
+#define SYMENGINE_INCLUDE_METHODS_DERIVED()                                    \
+    void accept(Visitor &v) const override;                                    \
+    void accept(EvalRealDoubleVisitorFinal &v) const override;