The base class for representing addition in symbolic expressions. More...

#include <add.h>

Inheritance diagram for SymEngine::Add:

Collaboration diagram for SymEngine::Add:

Public Member Functions
void	accept (Visitor &v) const override

void	accept (EvalRealDoubleVisitorFinal &v) const override

	Add (const RCP< const Number > &coef, umap_basic_num &&dict)
	Default constructor.

hash_t	__hash__ () const override
	Generates the hash representation.

bool	__eq__ (const Basic &o) const override
	Test equality.

int	compare (const Basic &o) const override
	Compares `Add` objects.

void	as_two_terms (const Ptr< RCP< const Basic > > &a, const Ptr< RCP< const Basic > > &b) const
	Converts the Add into a sum of two Basic objects.

bool	is_canonical (const RCP< const Number > &coef, const umap_basic_num &dict) const
	Checks if a given dictionary and coeffient is in cannonical form.

vec_basic	get_args () const override
	Returns the arguments of the Add.

const RCP< const Number > &	get_coef () const

const umap_basic_num &	get_dict () const

Public Member Functions inherited from SymEngine::Basic
TypeID	get_type_code () const

	Basic ()
	Constructor.

	Basic (const Basic &)=delete
	Delete the copy constructor and assignment.

Basic &	operator= (const Basic &)=delete
	Assignment operator in continuation with above.

	Basic (Basic &&)=delete
	Delete the move constructor and assignment.

Basic &	operator= (Basic &&)=delete
	Assignment operator in continuation with above.

virtual hash_t	__hash__ () const =0

hash_t	hash () const

virtual bool	__eq__ (const Basic &o) const =0
	Test equality.

bool	__neq__ (const Basic &o) const
	true if `this` is not equal to `o`.

int	__cmp__ (const Basic &o) const
	Comparison operator.

virtual int	compare (const Basic &o) const =0

std::string	__str__ () const

std::string	dumps () const
	Returns a string of the instance serialized.

RCP< const Basic >	subs (const map_basic_basic &subs_dict) const
	Substitutes 'subs_dict' into 'self'.

RCP< const Basic >	xreplace (const map_basic_basic &subs_dict) const

virtual RCP< const Basic >	expand_as_exp () const
	expands the special function in terms of exp function

virtual vec_basic	get_args () const =0
	Returns the list of arguments.

virtual void	accept (Visitor &v) const =0

virtual void	accept (EvalRealDoubleVisitorFinal &v) const =0

RCP< const Basic >	diff (const RCP< const Symbol > &x, bool cache=true) const

Public Member Functions inherited from SymEngine::EnableRCPFromThis< Basic >
RCP< Basic >	rcp_from_this ()
	Get RCP<T> pointer to self (it will cast the pointer to T)

RCP< const Basic >	rcp_from_this () const
	Get RCP<const T> pointer to self (it will cast the pointer to const T)

RCP< const T2 >	rcp_from_this_cast () const
	Get RCP<T2> pointer to self (it will cast the pointer to T2)

unsigned int	use_count () const

Static Public Member Functions
static RCP< const Basic >	from_dict (const RCP< const Number > &coef, umap_basic_num &&d)
	Create an appropriate instance from dictionary quickly.

static void	dict_add_term (umap_basic_num &d, const RCP< const Number > &coef, const RCP< const Basic > &t)
	Adds a new term to the expression.

static void	coef_dict_add_term (const Ptr< RCP< const Number > > &coef, umap_basic_num &d, const RCP< const Number > &c, const RCP< const Basic > &term)
	Updates the numerical coefficient and the dictionary.

static void	as_coef_term (const RCP< const Basic > &self, const Ptr< RCP< const Number > > &coef, const Ptr< RCP< const Basic > > &term)
	Converts a Basic `self` into the form of `coefficient * term`.

Static Public Member Functions inherited from SymEngine::Basic
static RCP< const Basic >	loads (const std::string &)
	Creates an instance of a serialized string.

Static Public Attributes
static const TypeID	type_code_id = SYMENGINE_ADD

Private Attributes
RCP< const Number >	coef_

umap_basic_num	dict_

Related Functions
(Note that these are not member functions.)
RCP< const Basic >	add (const RCP< const Basic > &a, const RCP< const Basic > &b)
	Adds two objects (safely).

RCP< const Basic >	add (const vec_basic &a)
	Sums the elements of a vector.

RCP< const Basic >	sub (const RCP< const Basic > &a, const RCP< const Basic > &b)
	Substracts `b` from `a`.

Additional Inherited Members
Data Fields inherited from SymEngine::Basic
TypeID	type_code_

Detailed Description

The base class for representing addition in symbolic expressions.

Internally this is implemented in as a numeric coefficient coef_ and a dictionary dict_ of key-value pairs. Consider the following example:

Add(coef_, {{key1, value1}, {key2, value2}, ... })

This represents the following expression,

 coef_ + key1*value1 + key2*value2 + ...

coef_ and the values of the dictionary may be numeric coefficients like Integer, RealDouble, Complex while their corresponding keys can be any symbolic expression except numeric coefficients and Mul objects with coefficient != 1.

For example, the following are valid representations

 Add(1, {{x, 2}, {y, 5}})
 Add(0, {{x, 1}, {y, 4}, {z, 3}})

The following representations are invalid (their valid equivalent is shown next to each of them)

 Add(1, {{x, 1}, {2*y, 3})   -> Add(1, {{x, 1}, {y, 6}})
 Add(0, {{x, 2}})             -> Mul(2, {{x, 1}})
 Add(1, {{x, 2}, {4, 6}})    -> Add(25, {{x, 2}})

A visual aid (from the SymEngine Wiki) for understanding this class in the broader context of the data structure for mathematical expressions is:

Sample Expression Data Structure

See also: Basic for an explanation of how the intialization works in conjuction to the constructors of the Basic class and the guarantees in Release.

Definition at line 26 of file add.h.

Constructor & Destructor Documentation

◆ Add()

SymEngine::Add::Add	(	const RCP< const Number > &	coef,
		umap_basic_num &&	dict
	)

Default constructor.

Precondition: Input must be in cannonical form.

Parameters

coef	numeric coefficient.
dict	dictionary of the expression without the coefficient.

Constructs Add from a dictionary by copying the contents of the dictionary.

Definition at line 64 of file add.cpp.

    : coef_{coef}, dict_{std::move(dict)} {
                       SYMENGINE_ASSIGN_TYPEID()
                           SYMENGINE_ASSERT(is_canonical(coef, dict_))}

Member Function Documentation

◆ eq()

bool SymEngine::Add::__eq__ ( const Basic & o ) const

overridevirtual

Test equality.

Deprecated:: Use eq(const Basic &a, const Basic &b) instead.

Parameters

o	a constant reference to object to test against.

Returns: True if this is equal to o.

This older implementation compares the elements of the coefficients and expressions for two objects.

Implements SymEngine::Basic.

Definition at line 88 of file add.cpp.

{
    if (is_a<Add>(o) and eq(*coef_, *(down_cast<const Add &>(o).coef_))
        and unified_eq(dict_, down_cast<const Add &>(o).dict_))
        return true;
 
    return false;
}

◆ hash()

hash_t SymEngine::Add::__hash__ ( ) const

overridevirtual

Generates the hash representation.

See also: Basic for an implementation to get the cached version.

Returns: 64-bit integer value for the hash.

This uses Basic.hash() to give a cached version of the hash.

Implements SymEngine::Basic.

Definition at line 72 of file add.cpp.

{
    hash_t seed = SYMENGINE_ADD, temp;
    hash_combine<Basic>(seed, *coef_);
    for (const auto &p : dict_) {
        temp = p.first->hash();
        hash_combine<Basic>(temp, *(p.second));
        seed ^= temp;
    }
    return seed;
}

◆ accept() [1/2]

void SymEngine::Add::accept ( EvalRealDoubleVisitorFinal & v ) const

overridevirtual

Implements SymEngine::Basic.

◆ accept() [2/2]

void SymEngine::Add::accept ( Visitor & v ) const

overridevirtual

Implements SymEngine::Basic.

◆ as_coef_term()

void SymEngine::Add::as_coef_term	(	const RCP< const Basic > &	self,
		const Ptr< RCP< const Number > > &	coef,
		const Ptr< RCP< const Basic > > &	term
	)

static

Converts a Basic self into the form of coefficient * term.

Parameters

coef	numerical coefficient.
term	the term.

Returns: Void.

This function converts the its representation as per the following logic:

If self is a Mul return the coefficient and the remaining term.
If self is not Mul or Add the coefficient is set one and the term is unchanged.
If self is a Number the term is set one and the coefficient is unchanged.

Definition at line 306 of file add.cpp.

{
    if (is_a<Mul>(*self)) {
        if (neq(*(down_cast<const Mul &>(*self).get_coef()), *one)) {
            *coef = (down_cast<const Mul &>(*self)).get_coef();
            // We need to copy our 'dict_' here, as 'term' has to have its own.
            map_basic_basic d2 = (down_cast<const Mul &>(*self)).get_dict();
            *term = Mul::from_dict(one, std::move(d2));
        } else {
            *coef = one;
            *term = self;
        }
    } else if (is_a_Number(*self)) {
        *coef = rcp_static_cast<const Number>(self);
        *term = one;
    } else {
        SYMENGINE_ASSERT(not is_a<Add>(*self));
        *coef = one;
        *term = self;
    }
}

◆ as_two_terms()

void SymEngine::Add::as_two_terms	(	const Ptr< RCP< const Basic > > &	a,
		const Ptr< RCP< const Basic > > &	b
	)		const

Converts the Add into a sum of two Basic objects.

Parameters

a	first basic object.
b	second basic object.

Returns: Void.

This implementation first converts a to a Mul and then performs addition.

Definition at line 287 of file add.cpp.

{
    auto p = dict_.begin();
    *a = mul(p->first, p->second);
    umap_basic_num d = dict_;
    d.erase(p->first);
    *b = Add::from_dict(coef_, std::move(d));
}

◆ coef_dict_add_term()

void SymEngine::Add::coef_dict_add_term	(	const Ptr< RCP< const Number > > &	coef,
		umap_basic_num &	d,
		const RCP< const Number > &	c,
		const RCP< const Basic > &	term
	)

static

Updates the numerical coefficient and the dictionary.

Parameters

coef	the numerical coefficient.
d	the dictionary containing the expression.
c	the numerical coefficient to be added.
term	the new term.

Returns: Void.

This implements the following logic:

If both c and term are numbers, then the term (c* term) is added to the existing coeff.
If term is not a number then the pair (c, term) is used to update the existing dict d (as a pair c, term).
In case term is Add and c=1, expands the Add into the coeff and d.

Definition at line 261 of file add.cpp.

{
    if (is_a_Number(*term)) {
        iaddnum(coef, mulnum(c, rcp_static_cast<const Number>(term)));
    } else if (is_a<Add>(*term)) {
        if (c->is_one()) {
            for (const auto &q : (down_cast<const Add &>(*term)).dict_)
                Add::dict_add_term(d, q.second, q.first);
            iaddnum(coef, down_cast<const Add &>(*term).coef_);
        } else {
            Add::dict_add_term(d, c, term);
        }
    } else {
        RCP<const Number> coef2;
        RCP<const Basic> t;
        Add::as_coef_term(term, outArg(coef2), outArg(t));
        Add::dict_add_term(d, mulnum(c, coef2), t);
    }
}

◆ compare()

int SymEngine::Add::compare ( const Basic & o ) const

overridevirtual

Compares Add objects.

Parameters

o	object to test against.

See also: unified_compare() for the actual implementation.

Returns: 1 if this is equal to o otherwise (-1).

This function takes a Basic object, checks if it is an Add object, and subsequently compares exhaustively:

The number of elements.
The coefficients.
Each element of the dictionary.

Note: Since the map_basic_num representation is not cached by Add after being computed, this is slow.

<

Todo:: cache adict and bdict

Implements SymEngine::Basic.

Definition at line 107 of file add.cpp.

{
    SYMENGINE_ASSERT(is_a<Add>(o))
    const Add &s = down_cast<const Add &>(o);
    // # of elements
    if (dict_.size() != s.dict_.size())
        return (dict_.size() < s.dict_.size()) ? -1 : 1;
 
    // coef
    int cmp = coef_->__cmp__(*s.coef_);
    if (cmp != 0)
        return cmp;
 
    // Compare dictionaries (slow):
    map_basic_num adict(dict_.begin(), dict_.end());
    map_basic_num bdict(s.dict_.begin(), s.dict_.end());
    return unified_compare(adict, bdict);
}

◆ dict_add_term()

void SymEngine::Add::dict_add_term	(	umap_basic_num &	d,
		const RCP< const Number > &	coef,
		const RCP< const Basic > &	t
	)

static

Adds a new term to the expression.

Precondition: The coefficient of the new term is non-zero.

Parameters

d	dictionary to be updated.
coef	new coefficient.
t	new term.

Returns: Void.

Adds (coeff*t) to the dict d inplace.

Warning: We assume that t has no numerical coefficients, and coef has only numerical coefficients.

Definition at line 237 of file add.cpp.

{
    auto it = d.find(t);
    if (it == d.end()) {
        // Not found, add it in if it is nonzero:
        if (not(coef->is_zero()))
            insert(d, t, coef);
    } else {
        iaddnum(outArg(it->second), coef);
        if (it->second->is_zero())
            d.erase(it);
    }
}

◆ from_dict()

RCP< const Basic > SymEngine::Add::from_dict	(	const RCP< const Number > &	coef,
		umap_basic_num &&	d
	)

static

Create an appropriate instance from dictionary quickly.

Precondition: The dictionary must be in canonical form.

See also: Mul for how Pow gets returned.; Basic for the guarantees and expectations.

Parameters

coef	the numeric coefficient.
d	the dictionary of the expression without the coefficient.

Returns: coef if the dictionary is empty (size 0).; Mul if the dictionary has one element which is a Mul.; Integer if the dictionary has one element which is a Integer.; Symbol if the dictionary has one element which is a Symbol.; Pow if the dictionary has one element which is a Pow.; Add if the size of the dictionary is greater than 1.

Quick implementation which depends only on the size of d.

The speed benefits also arise from the fact that when using the SymEngine::RCP in production mode (which is not thread safe) then when a single Mul object is encountered, instead of copying its dict_, it is reused instead.

That is, when WITH_SYMENGINE_THREAD_SAFE is not defined and WITH_SYMENGINE_RCP is defined, we can "steal" its dictionary by explictly casting away the const'ness. Since the refcount_ is 1, nothing else is using the Mul.

Definition at line 140 of file add.cpp.

{
    if (d.size() == 0) {
        return coef;
    } else if (d.size() == 1 and coef->is_zero()) {
        auto p = d.begin();
        if (is_a<Integer>(*(p->second))) {
            if (down_cast<const Integer &>(*(p->second)).is_zero()) {
                return p->second; // Symbol
            }
            if (down_cast<const Integer &>(*(p->second)).is_one()) {
                return p->first; // Integer
            }
            if (is_a<Mul>(*(p->first))) {
#if !defined(WITH_SYMENGINE_THREAD_SAFE) && defined(WITH_SYMENGINE_RCP)
                if (down_cast<const Mul &>(*(p->first)).use_count() == 1) {
                    // We can steal the dictionary:
                    // Cast away const'ness, so that we can move 'dict_', since
                    // 'p->first' will be destroyed when 'd' is at the end of
                    // this function, so we "steal" its dict_ to avoid an
                    // unnecessary copy. We know the refcount_ is one, so
                    // nobody else is using the Mul except us.
                    const map_basic_basic &d2
                        = down_cast<const Mul &>(*(p->first)).get_dict();
                    map_basic_basic &d3 = const_cast<map_basic_basic &>(d2);
                    return Mul::from_dict(p->second, std::move(d3));
                } else {
#else
                {
#endif
                    // We need to copy the dictionary:
                    map_basic_basic d2
                        = down_cast<const Mul &>(*(p->first)).get_dict();
                    return Mul::from_dict(
                        p->second,
                        std::move(d2)); // Can return a Pow object here
                }
            }
            map_basic_basic m;
            if (is_a<Pow>(*(p->first))) {
                insert(m, down_cast<const Pow &>(*(p->first)).get_base(),
                       down_cast<const Pow &>(*(p->first)).get_exp());
            } else {
                insert(m, p->first, one);
            }
            return make_rcp<const Mul>(p->second,
                                       std::move(m)); // Returns a Mul from here
        }
        map_basic_basic m;
        if (is_a_Number(*p->second)) {
            if (is_a<Mul>(*(p->first))) {
#if !defined(WITH_SYMENGINE_THREAD_SAFE) && defined(WITH_SYMENGINE_RCP)
                if (down_cast<const Mul &>(*(p->first)).use_count() == 1) {
                    // We can steal the dictionary:
                    // Cast away const'ness, so that we can move 'dict_', since
                    // 'p->first' will be destroyed when 'd' is at the end of
                    // this function, so we "steal" its dict_ to avoid an
                    // unnecessary copy. We know the refcount_ is one, so
                    // nobody else is using the Mul except us.
                    const map_basic_basic &d2
                        = down_cast<const Mul &>(*(p->first)).get_dict();
                    map_basic_basic &d3 = const_cast<map_basic_basic &>(d2);
                    return Mul::from_dict(p->second, std::move(d3));
                } else {
#else
                {
#endif
                    // We need to copy the dictionary:
                    map_basic_basic d2
                        = down_cast<const Mul &>(*(p->first)).get_dict();
                    return Mul::from_dict(p->second,
                                          std::move(d2)); // May return a Pow
                }
            }
            if (is_a<Pow>(*p->first)) {
                insert(m, down_cast<const Pow &>(*(p->first)).get_base(),
                       down_cast<const Pow &>(*(p->first)).get_exp());
            } else {
                insert(m, p->first, one);
            }
            return make_rcp<const Mul>(p->second, std::move(m));
        } else {
            insert(m, p->first, one);
            insert(m, p->second, one);
            return make_rcp<const Mul>(one, std::move(m));
        }
    } else {
        return make_rcp<const Add>(coef, std::move(d)); // returns an Add
    }
}

◆ get_args()

vec_basic SymEngine::Add::get_args ( ) const

overridevirtual

Returns the arguments of the Add.

Returns: list of arguments.; const reference to the coefficient of the Add.

For an Add of the form:

Add(coef_, {{key1, value1}, {key2, value2}, ... })

If coef_ is non-zero it returns:

{coef_, key1*value1, key2*value2, ... }

otherwise it returns:

{key1*value1, key2*value2, ... }

Implements SymEngine::Basic.

Definition at line 397 of file add.cpp.

{
    vec_basic args;
    if (not coef_->is_zero()) {
        args.reserve(dict_.size() + 1);
        args.push_back(coef_);
    } else {
        args.reserve(dict_.size());
    }
    for (const auto &p : dict_) {
        if (eq(*p.second, *one)) {
            args.push_back(p.first);
        } else {
            args.push_back(Add::from_dict(zero, {{p.first, p.second}}));
        }
    }
    return args;
}

◆ get_coef()

const RCP< const Number > & SymEngine::Add::get_coef ( ) const

inline

Returns: const reference to the dictionary of the Add

Definition at line 142 of file add.h.

◆ get_dict()

const umap_basic_num & SymEngine::Add::get_dict ( ) const

inline

Definition at line 148 of file add.h.

    {
        return dict_;
    }

◆ is_canonical()

bool SymEngine::Add::is_canonical	(	const RCP< const Number > &	coef,
		const umap_basic_num &	dict
	)		const

Checks if a given dictionary and coeffient is in cannonical form.

Parameters

coef	numerical coefficient.
dict	dictionary of remaining expression terms.

Returns: true if canonical.

This function ensures that each term in dict is in canonical form. The implementation in the form of a exclusion list (defaults to true).

Note: Canonical form requires the existance of both coef and dict, so null coefficients and purely numerical (empty dictionaries) are also not considered to be in canonical form. Also, the ordering is important, it must be (coeff, dict) and not (dict, coeff).

Some non-cannonical forms are:

.
.
$2 \times 3$ .
$x \times 0$ .
$1 \times x$ has the wrong order.
$3x \times 2$ is actually just .

Definition at line 348 of file add.cpp.

{
    if (coef == null)
        return false;
    if (dict.size() == 0)
        return false;
    if (dict.size() == 1) {
        // e.g. 0 + x, 0 + 2x
        if (coef->is_zero())
            return false;
    }
    // Check that each term in 'dict' is in canonical form
    for (const auto &p : dict) {
        if (p.first == null)
            return false;
        if (p.second == null)
            return false;
        // e.g. 2*3
        if (is_a_Number(*p.first))
            return false;
        // e.g. 1*x (={1:x}), this should rather be just x (={x:1})
        if (is_a<Integer>(*p.first)
            and down_cast<const Integer &>(*p.first).is_one())
            return false;
        // e.g. x*0
        if (is_a_Number(*p.second)
            and down_cast<const Number &>(*p.second).is_zero())
            return false;
 
        // e.g. {3x: 2}, this should rather be just {x: 6}
        if (is_a<Mul>(*p.first)
            and not(down_cast<const Mul &>(*p.first).get_coef()->is_one()))
            return false;
    }
    return true;
}

Friends And Related Function Documentation

◆ add() [1/2]

RCP< const Basic > add	(	const RCP< const Basic > &	a,
		const RCP< const Basic > &	b
	)

Parameters

a	is a `Basic` object.
b	is a `Basic` object.

Returns: a+b in its most aproriate form.

Definition at line 425 of file add.cpp.

{
    SymEngine::umap_basic_num d;
    RCP<const Number> coef;
    RCP<const Basic> t;
    if (is_a<Add>(*a) and is_a<Add>(*b)) {
        coef = (down_cast<const Add &>(*a)).get_coef();
        d = (down_cast<const Add &>(*a)).get_dict();
        for (const auto &p : (down_cast<const Add &>(*b)).get_dict())
            Add::dict_add_term(d, p.second, p.first);
        iaddnum(outArg(coef), down_cast<const Add &>(*b).get_coef());
    } else if (is_a<Add>(*a)) {
        coef = (down_cast<const Add &>(*a)).get_coef();
        d = (down_cast<const Add &>(*a)).get_dict();
        if (is_a_Number(*b)) {
            if (not down_cast<const Number &>(*b).is_zero()) {
                iaddnum(outArg(coef), rcp_static_cast<const Number>(b));
            }
        } else {
            RCP<const Number> coef2;
            Add::as_coef_term(b, outArg(coef2), outArg(t));
            Add::dict_add_term(d, coef2, t);
        }
    } else if (is_a<Add>(*b)) {
        coef = (down_cast<const Add &>(*b)).get_coef();
        d = (down_cast<const Add &>(*b)).get_dict();
        if (is_a_Number(*a)) {
            if (not down_cast<const Number &>(*a).is_zero()) {
                iaddnum(outArg(coef), rcp_static_cast<const Number>(a));
            }
        } else {
            RCP<const Number> coef2;
            Add::as_coef_term(a, outArg(coef2), outArg(t));
            Add::dict_add_term(d, coef2, t);
        }
    } else {
        Add::as_coef_term(a, outArg(coef), outArg(t));
        Add::dict_add_term(d, coef, t);
        Add::as_coef_term(b, outArg(coef), outArg(t));
        Add::dict_add_term(d, coef, t);
        auto it = d.find(one);
        if (it == d.end()) {
            coef = zero;
        } else {
            coef = it->second;
            d.erase(it);
        }
        return Add::from_dict(coef, std::move(d));
    }
    return Add::from_dict(coef, std::move(d));
}

◆ add() [2/2]

RCP< const Basic > add ( const vec_basic & a )

Parameters

a	is a vector.

Returns: sum of elements of the input vector a.

Definition at line 481 of file add.cpp.

{
    SymEngine::umap_basic_num d;
    RCP<const Number> coef = zero;
    for (const auto &i : a) {
        Add::coef_dict_add_term(outArg(coef), d, one, i);
    }
    return Add::from_dict(coef, std::move(d));
}

◆ sub()

RCP< const Basic > sub	(	const RCP< const Basic > &	a,
		const RCP< const Basic > &	b
	)

Parameters

a	is the minuend.
b	is the subtrahend.

Returns: the difference a-b.

Definition at line 495 of file add.cpp.

{
    return add(a, mul(minus_one, b));
}

Field Documentation

◆ coef_

RCP<const Number> SymEngine::Add::coef_

private

The numeric coefficient of the expression (e.g. 2 in 2+x+y).

Definition at line 29 of file add.h.

◆ dict_

umap_basic_num SymEngine::Add::dict_

private

The expression without its coefficient as a dictionary (e.g. x+y in 2+x+y).

Definition at line 31 of file add.h.

◆ type_code_id

const TypeID SymEngine::Add::type_code_id = SYMENGINE_ADD

static

Type_code_id shared by all instances

Definition at line 35 of file add.h.

The documentation for this class was generated from the following files:

/home/runner/work/symengine/symengine/symengine/add.h
/home/runner/work/symengine/symengine/symengine/add.cpp

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Attributes

Related Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Add()

Member Function Documentation

◆ __eq__()

◆ __hash__()

◆ accept() [1/2]

◆ accept() [2/2]

◆ as_coef_term()

◆ as_two_terms()

◆ coef_dict_add_term()

◆ compare()

◆ dict_add_term()

◆ from_dict()

◆ get_args()

◆ get_coef()

◆ get_dict()

◆ is_canonical()

Friends And Related Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ sub()

Field Documentation

◆ coef_

◆ dict_

◆ type_code_id

◆ eq()

◆ hash()