Main namespace for SymEngine package. More...

Data Structures
class	Abs

class	ACos

class	ACosh

class	ACot

class	ACoth

class	ACsc

class	ACsch

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

class	AlgebraicVisitor

class	And

class	ASec

class	ASech

class	ASin

class	ASinh

class	Assumptions

class	ATan

class	ATan2

class	ATanh

class	AtomsVisitor

class	BaseVisitor

class	Basic
	The lowest unit of symbolic representation. More...

class	BasicToMExprPoly

class	BasicToMIntPoly

class	BasicToMPolyBase

class	BasicToUExprPoly

class	BasicToUIntPoly

class	BasicToUPolyBase

class	BasicToURatPoly

class	Beta

class	Boolean

class	BooleanAtom

class	BoundaryVisitor

class	C89CodePrinter

class	C99CodePrinter

class	Ceiling

class	CodePrinter

class	CoeffVisitor

class	Complement

class	Complex
	Complex Class. More...

class	ComplexBase
	ComplexBase Class for deriving all complex classes. More...

class	ComplexDouble
	Complex Double Class to hold std::complex<double> values. More...

class	Complexes

class	ComplexMPC

class	ComplexVisitor

class	ConditionSet

class	Conjugate

class	ConjugateMatrix

class	ConjugateMatrixVisitor

class	Constant

class	ContainerBaseIter

class	ContainerForIter

class	ContainerRevIter

class	Contains

class	Cos

class	Cosh

class	Cot

class	Coth

class	CountOpsVisitor

class	Csc

class	Csch

class	CSRMatrix

class	DenseMatrix

class	Derivative

class	DiagonalMatrix

class	DiffVisitor

class	Dirichlet_eta

class	Dummy

class	EmptySet

class	EnableRCPFromThis

class	Equality

class	Erf

class	Erfc

class	EvalComplexDoubleVisitor

class	EvalDoubleVisitor

class	EvalRealDoubleVisitor

class	EvalRealDoubleVisitorFinal

class	EvalRealDoubleVisitorPattern

class	Evaluate
	A class that will evaluate functions numerically. More...

class	EvaluateComplexDouble

class	EvaluateDouble
	Evaluate functions with double precision. More...

class	EvaluateInfty

class	EvaluateNaN

class	EvaluateRealDouble

class	EvalVisitor

class	ExpandVisitor

class	Expression

class	FiniteSet

class	FiniteVisitor

class	Floor

class	fmpq_poly_wrapper

class	fmpq_wrapper

class	fmpz_poly_factor_wrapper

class	fmpz_poly_wrapper

class	fmpz_wrapper

class	FreeSymbolsVisitor

class	FuncArgTracker

class	Function

class	FunctionSymbol

class	FunctionWrapper

class	GaloisField

class	GaloisFieldDict

class	Gamma

class	HadamardProduct

class	HasSymbolVisitor

class	HyperbolicBase

class	HyperbolicFunction

class	IdentityMatrix

class	ImageSet

class	ImmutableDenseMatrix

class	Infty

class	InfVisitor

class	Integer
	Integer Class. More...

class	Integers

class	IntegerVisitor

class	Intersection

class	Interval

class	InverseHyperbolicFunction

class	InverseTrigFunction

class	InvertComplexVisitor

class	IRBuilder

struct	is_a_UPoly

struct	is_base_of_multiple

struct	is_base_of_multiple< Derived, First >

class	IsALinearArgTrigVisitor

class	JSCodePrinter

class	JuliaStrPrinter

class	KroneckerDelta

class	LambdaComplexDoubleVisitor

class	LambdaDoubleVisitor

class	LambdaRealDoubleVisitor

class	LambertW

class	LatexPrinter

class	LessThan

class	LeviCivita

class	LocalStopVisitor

class	Log

class	LogGamma

class	LowerGamma

class	MathMLPrinter

class	MatrixAdd

class	MatrixBase

class	MatrixDiagonalVisitor

class	MatrixExpr

class	MatrixLowerVisitor

class	MatrixMul

class	MatrixRealVisitor

class	MatrixSizeVisitor

class	MatrixSquareVisitor

class	MatrixSymbol

class	MatrixSymmetricVisitor

class	MatrixToeplitzVisitor

class	MatrixTraceVisitor

class	MatrixUpperVisitor

class	MatrixZeroVisitor

class	Max

class	MExprDict

class	MExprPoly

class	Min

class	MIntDict

class	MIntPoly

class	mp_randstate

class	mpq_view_flint

class	mpz_view_flint

class	MSubsVisitor

class	MSymEnginePoly

class	Mul

class	MultiArgFunction

class	NaN

class	Naturals

class	Naturals0

class	NeedsSymbolicExpansionVisitor

class	NegativeVisitor

class	NonNegativeVisitor

class	NonPositiveVisitor

class	Not

class	Number

class	NumberWrapper

class	NumerDenomVisitor

class	ODictWrapper

class	OneArgFunction

class	OptsCSEVisitor

class	Or

class	Piecewise

class	PolyGamma

class	PolyGeneratorVisitor

class	PolyGeneratorVisitorPow

class	PolynomialVisitor

class	PositiveVisitor

class	Pow

class	Precedence

class	PrimePi

class	Primorial

struct	PrinterBasicCmp
	Less operator `(<)` using cmp: More...

class	Rational
	Rational Class. More...

class	Rationals

class	RationalVisitor

struct	RCPBasicHash
	Our hash: More...

struct	RCPBasicKeyEq
	Our comparison `(==)` More...

struct	RCPBasicKeyLess
	Our less operator `(<)`: More...

struct	RCPIntegerKeyLess
	less operator (<) for Integers More...

class	RealDouble
	RealDouble Class to hold double values. More...

class	RealImagVisitor

class	RealMPFR

class	Reals

class	RealVisitor

class	RebuildVisitor

class	RefineVisitor

class	Relational

struct	remove_reference

struct	remove_reference< T & >

class	RewriteAsCos

class	RewriteAsExp

class	RewriteAsSin

class	SbmlPrinter

class	Sec

class	Sech

class	SeriesBase

class	SeriesCoeffInterface

class	SeriesVisitor

class	Set

class	Sieve

class	Sign

class	SimplifyVisitor

class	Sin

class	Sinh

class	SSubsVisitor

class	StopVisitor

class	StrictLessThan

class	StringBox

class	StrPrinter

class	Subs

class	SubsVisitor

class	SupVisitor

class	Symbol

class	Tan

class	Tanh

class	Trace

class	TransformVisitor

class	Transpose

class	TransposeVisitor

class	TrigBase

class	TrigFunction

class	Truncate

class	Tuple

struct	two_by_two_matrix

class	TwoArgBasic

class	UDictWrapper

class	UExprDict

class	UExprPoly

class	UExprPolyBase

class	UIntDict

class	UIntPoly

class	UIntPolyBase

class	Unequality

class	UnevaluatedExpr

class	UnicodePrinter

class	Union

class	UnivariateSeries
	UnivariateSeries Class. More...

class	UniversalSet

class	UNonExprPoly

class	UPolyBase

class	UpperGamma

class	URatDict

class	URatPoly

class	URatPolyBase

class	USymEnginePoly

struct	vec_hash

class	Visitor

class	Xor

class	XReplaceVisitor

class	ZeroMatrix

class	ZeroVisitor

class	Zeta

Typedefs
typedef std::unordered_map< RCP< const Basic >, bool, RCPBasicHash, RCPBasicKeyEq >	umap_basic_bool

typedef uint64_t	hash_t

typedef std::unordered_map< RCP< const Basic >, RCP< const Number >, RCPBasicHash, RCPBasicKeyEq >	umap_basic_num

typedef std::unordered_map< short, RCP< const Basic > >	umap_short_basic

typedef std::unordered_map< int, RCP< const Basic > >	umap_int_basic

typedef std::unordered_map< RCP< const Basic >, RCP< const Basic >, RCPBasicHash, RCPBasicKeyEq >	umap_basic_basic

typedef std::unordered_set< RCP< const Basic >, RCPBasicHash, RCPBasicKeyEq >	uset_basic

typedef std::vector< int >	vec_int

typedef std::vector< RCP< const Basic > >	vec_basic

typedef std::vector< RCP< const Integer > >	vec_integer

typedef std::vector< unsigned int >	vec_uint

typedef std::vector< integer_class >	vec_integer_class

typedef std::vector< RCP< const Symbol > >	vec_sym

typedef std::set< RCP< const Basic >, RCPBasicKeyLess >	set_basic

typedef std::multiset< RCP< const Basic >, RCPBasicKeyLess >	multiset_basic

typedef std::map< vec_uint, unsigned long long int >	map_vec_uint

typedef std::map< vec_uint, integer_class >	map_vec_mpz

typedef std::map< RCP< const Basic >, RCP< const Number >, RCPBasicKeyLess >	map_basic_num

typedef std::map< RCP< const Basic >, RCP< const Basic >, RCPBasicKeyLess >	map_basic_basic

typedef std::map< RCP< const Integer >, unsigned, RCPIntegerKeyLess >	map_integer_uint

typedef std::map< unsigned, integer_class >	map_uint_mpz

typedef std::map< unsigned, rational_class >	map_uint_mpq

typedef std::map< int, Expression >	map_int_Expr

typedef std::unordered_map< RCP< const Basic >, unsigned int, RCPBasicHash, RCPBasicKeyEq >	umap_basic_uint

typedef std::vector< std::pair< RCP< const Basic >, RCP< const Basic > > >	vec_pair

typedef std::unordered_map< vec_uint, integer_class, vec_hash< vec_uint > >	umap_uvec_mpz

typedef std::unordered_map< vec_int, integer_class, vec_hash< vec_int > >	umap_vec_mpz

typedef std::unordered_map< vec_int, Expression, vec_hash< vec_int > >	umap_vec_expr

template<bool B, class T = void>
using	enable_if_t = typename std::enable_if< B, T >::type

typedef std::function< double(const Basic &)>	fn

typedef TwoArgBasic< Function >	TwoArgFunction

typedef std::set< RCP< const Boolean >, RCPBasicKeyLess >	set_boolean

typedef std::vector< RCP< const Boolean > >	vec_boolean

typedef std::vector< std::pair< RCP< const Basic >, RCP< const Boolean > > >	PiecewiseVec

typedef std::vector< std::pair< int, int > >	permutelist

typedef boost::multiprecision::number< boost::multiprecision::cpp_int_backend<>, boost::multiprecision::et_off >	integer_class

typedef boost::multiprecision::number< boost::multiprecision::cpp_rational_backend, boost::multiprecision::et_off >	rational_class

typedef std::set< RCP< const Set >, RCPBasicKeyLess >	set_set

Enumerations
enum	TypeID { TypeID_Count }

enum class	EvalfDomain { Complex = 0 , Real = 1 , Symbolic = 2 }

enum class	PrecedenceEnum { Relational , Add , Mul , Pow , Atom }

enum class	tribool { indeterminate = -1 , trifalse = 0 , tritrue = 1 }

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`.

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)

void	as_real_imag (const RCP< const Basic > &x, const Ptr< RCP< const Basic > > &real, const Ptr< RCP< const Basic > > &imag)

bool	eq (const Basic &a, const Basic &b)
	Checks equality for `a` and `b`

bool	neq (const Basic &a, const Basic &b)
	Checks inequality for `a` and `b`

template<class T >
bool	is_a (const Basic &b)
	Templatised version to check is_a type.

template<class T >
bool	is_a_sub (const Basic &b)

bool	is_same_type (const Basic &a, const Basic &b)
	Returns true if `a` and `b` are exactly the same type `T`.

std::ostream &	operator<< (std::ostream &out, const SymEngine::Basic &p)
	`<<` Operator

template<typename T >
void	hash_combine_impl (hash_t &seed, const T &v, typename std::enable_if< std::is_base_of< Basic, T >::value >::type *=nullptr)
	Templatised version to combine hash.

template<typename T >
void	hash_combine_impl (hash_t &seed, const T &v, typename std::enable_if< std::is_integral< T >::value >::type *=nullptr)

void	hash_combine_impl (hash_t &seed, const std::string &s)

void	hash_combine_impl (hash_t &seed, const double &s)

template<class T >
void	hash_combine (hash_t &seed, const T &v)

template<typename T >
std::string	to_string (const T &value)
	workaround for MinGW bug

std::string	type_code_name (TypeID id)

const char *	get_version ()

bool	is_a_Atom (const Basic &b)
	Returns true if `b` is an atom. i.e. b.get_args returns an empty vector.

RCP< const Basic >	expand (const RCP< const Basic > &self, bool deep=true)
	Expands `self`

void	as_numer_denom (const RCP< const Basic > &x, const Ptr< RCP< const Basic > > &numer, const Ptr< RCP< const Basic > > &denom)

RCP< const Basic >	rewrite_as_exp (const RCP< const Basic > &x)

RCP< const Basic >	rewrite_as_sin (const RCP< const Basic > &x)

RCP< const Basic >	rewrite_as_cos (const RCP< const Basic > &x)

void	cse (vec_pair &replacements, vec_basic &reduced_exprs, const vec_basic &exprs)

RCP< const Number >	pow_number (const Complex &x, unsigned long n)

bool	is_a_Complex (const Basic &b)

RCP< const ComplexDouble >	complex_double (std::complex< double > x)

RCP< const ComplexDouble >	complex_double (double real, double imag)

RCP< const Constant >	constant (const std::string &name)
	inline version to return `Constant`

umap_basic_basic	opt_cse (const vec_basic &exprs)

void	tree_cse (vec_pair &replacements, vec_basic &reduced_exprs, const vec_basic &exprs, umap_basic_basic &opt_subs)

std::vector< unsigned >	set_diff (const std::set< unsigned > &a, const std::vector< unsigned > &b)

void	add_to_sorted_vec (std::vector< unsigned > &vec, unsigned number)

void	match_common_args (const std::string &func_class, const vec_basic &funcs_, umap_basic_basic &opt_subs)

vec_basic	set_as_vec (const set_basic &s)

template<typename T >
bool	is_aligned (T *p, size_t n=alignof(T))

static std::string	_str (const Basic &a)

void	jacobian (const DenseMatrix &A, const DenseMatrix &x, DenseMatrix &result, bool diff_cache)

void	sjacobian (const DenseMatrix &A, const DenseMatrix &x, DenseMatrix &result, bool diff_cache)

void	diff (const DenseMatrix &A, const RCP< const Symbol > &x, DenseMatrix &result, bool diff_cache)

void	sdiff (const DenseMatrix &A, const RCP< const Basic > &x, DenseMatrix &result, bool diff_cache)

void	conjugate_dense (const DenseMatrix &A, DenseMatrix &B)

void	transpose_dense (const DenseMatrix &A, DenseMatrix &B)

void	conjugate_transpose_dense (const DenseMatrix &A, DenseMatrix &B)

void	submatrix_dense (const DenseMatrix &A, DenseMatrix &B, unsigned row_start, unsigned col_start, unsigned row_end, unsigned col_end, unsigned row_step, unsigned col_step)

void	add_dense_dense (const DenseMatrix &A, const DenseMatrix &B, DenseMatrix &C)

void	add_dense_scalar (const DenseMatrix &A, const RCP< const Basic > &k, DenseMatrix &B)

void	mul_dense_dense (const DenseMatrix &A, const DenseMatrix &B, DenseMatrix &C)

void	elementwise_mul_dense_dense (const DenseMatrix &A, const DenseMatrix &B, DenseMatrix &C)

void	mul_dense_scalar (const DenseMatrix &A, const RCP< const Basic > &k, DenseMatrix &B)

void	row_exchange_dense (DenseMatrix &A, unsigned i, unsigned j)

void	row_mul_scalar_dense (DenseMatrix &A, unsigned i, RCP< const Basic > &c)

void	row_add_row_dense (DenseMatrix &A, unsigned i, unsigned j, RCP< const Basic > &c)

void	permuteFwd (DenseMatrix &A, permutelist &pl)

void	column_exchange_dense (DenseMatrix &A, unsigned i, unsigned j)

void	pivoted_gaussian_elimination (const DenseMatrix &A, DenseMatrix &B, permutelist &pl)

void	fraction_free_gaussian_elimination (const DenseMatrix &A, DenseMatrix &B)

void	pivoted_fraction_free_gaussian_elimination (const DenseMatrix &A, DenseMatrix &B, permutelist &pl)

void	pivoted_gauss_jordan_elimination (const DenseMatrix &A, DenseMatrix &B, permutelist &pl)

void	fraction_free_gauss_jordan_elimination (const DenseMatrix &A, DenseMatrix &B)

void	pivoted_fraction_free_gauss_jordan_elimination (const DenseMatrix &A, DenseMatrix &B, permutelist &pl)

unsigned	pivot (DenseMatrix &B, unsigned r, unsigned c)

void	reduced_row_echelon_form (const DenseMatrix &A, DenseMatrix &b, vec_uint &pivot_cols, bool normalize_last)

void	diagonal_solve (const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x)

void	back_substitution (const DenseMatrix &U, const DenseMatrix &b, DenseMatrix &x)

void	forward_substitution (const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x)

void	fraction_free_gaussian_elimination_solve (const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x)

void	fraction_free_gauss_jordan_solve (const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x, bool pivot)

void	fraction_free_LU_solve (const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x)

void	LU_solve (const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x)

void	pivoted_LU_solve (const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x)

void	LDL_solve (const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x)

void	fraction_free_LU (const DenseMatrix &A, DenseMatrix &LU)

void	LU (const DenseMatrix &A, DenseMatrix &L, DenseMatrix &U)

void	pivoted_LU (const DenseMatrix &A, DenseMatrix &LU, permutelist &pl)

void	pivoted_LU (const DenseMatrix &A, DenseMatrix &L, DenseMatrix &U, permutelist &pl)

void	fraction_free_LDU (const DenseMatrix &A, DenseMatrix &L, DenseMatrix &D, DenseMatrix &U)

void	QR (const DenseMatrix &A, DenseMatrix &Q, DenseMatrix &R)

void	LDL (const DenseMatrix &A, DenseMatrix &L, DenseMatrix &D)

void	cholesky (const DenseMatrix &A, DenseMatrix &L)

bool	is_symmetric_dense (const DenseMatrix &A)

RCP< const Basic >	det_bareis (const DenseMatrix &A)

void	berkowitz (const DenseMatrix &A, std::vector< DenseMatrix > &polys)

RCP< const Basic >	det_berkowitz (const DenseMatrix &A)

void	char_poly (const DenseMatrix &A, DenseMatrix &B)

void	inverse_fraction_free_LU (const DenseMatrix &A, DenseMatrix &B)

void	inverse_LU (const DenseMatrix &A, DenseMatrix &B)

void	inverse_pivoted_LU (const DenseMatrix &A, DenseMatrix &B)

void	inverse_gauss_jordan (const DenseMatrix &A, DenseMatrix &B)

void	dot (const DenseMatrix &A, const DenseMatrix &B, DenseMatrix &C)

void	cross (const DenseMatrix &A, const DenseMatrix &B, DenseMatrix &C)

RCP< const Set >	eigen_values (const DenseMatrix &A)

void	eye (DenseMatrix &A, int k)

void	diag (DenseMatrix &A, vec_basic &v, int k)

void	ones (DenseMatrix &A)

void	zeros (DenseMatrix &A)

template<typename T >
static RCP< const Basic >	fdiff (const T &self, RCP< const Symbol > x, DiffVisitor &visitor)

static bool	fdiff (const Ptr< RCP< const Basic > > &ret, const Zeta &self, unsigned index)

static bool	fdiff (const Ptr< RCP< const Basic > > &ret, const UpperGamma &self, unsigned index)

static bool	fdiff (const Ptr< RCP< const Basic > > &ret, const LowerGamma &self, unsigned index)

static bool	fdiff (const Ptr< RCP< const Basic > > &ret, const PolyGamma &self, unsigned index)

static bool	fdiff (const Ptr< RCP< const Basic > > &ret, const Function &self, unsigned index)

template<typename P >
static RCP< const Basic >	diff_upolyflint (const P &self, const Symbol &x)

template<typename Poly , typename Dict >
static RCP< const Basic >	diff_upoly (const Poly &self, const Symbol &x)

template<typename Container , typename Poly >
static RCP< const Basic >	diff_mpoly (const MSymEnginePoly< Container, Poly > &self, const RCP< const Symbol > &x)

static RCP< const Symbol >	get_dummy (const Basic &b, std::string name)

RCP< const Basic >	diff (const RCP< const Basic > &arg, const RCP< const Symbol > &x, bool cache=true)
	Differentiation w.r.t symbols.

RCP< const Basic >	sdiff (const RCP< const Basic > &arg, const RCP< const Basic > &x, bool cache)
	SymPy style differentiation for non-symbol variables.

std::ostream &	operator<< (std::ostream &out, const SymEngine::umap_basic_num &d)
	print functions

std::ostream &	operator<< (std::ostream &out, const SymEngine::map_basic_num &d)

std::ostream &	operator<< (std::ostream &out, const SymEngine::map_basic_basic &d)

std::ostream &	operator<< (std::ostream &out, const SymEngine::umap_basic_basic &d)

std::ostream &	operator<< (std::ostream &out, const SymEngine::vec_basic &d)

std::ostream &	operator<< (std::ostream &out, const SymEngine::set_basic &d)

std::ostream &	operator<< (std::ostream &out, const SymEngine::map_int_Expr &d)

std::ostream &	operator<< (std::ostream &out, const SymEngine::vec_pair &d)

bool	vec_basic_eq_perm (const vec_basic &a, const vec_basic &b)
	misc functions

template<typename T1 , typename T2 , typename T3 >
void	insert (T1 &m, const T2 &first, const T3 &second)

template<class M , typename C = std::less<typename M::key_type>>
std::vector< typename M::key_type >	sorted_keys (const M &d)

template<typename T , typename U >
bool	unified_eq (const std::pair< T, U > &a, const std::pair< T, U > &b)

template<typename T , typename U >
bool	unified_eq (const std::set< T, U > &a, const std::set< T, U > &b)

template<typename T , typename U >
bool	unified_eq (const std::multiset< T, U > &a, const std::multiset< T, U > &b)

template<typename K , typename V , typename C >
bool	unified_eq (const std::map< K, V, C > &a, const std::map< K, V, C > &b)

template<typename K , typename V , typename H , typename E >
bool	unified_eq (const std::unordered_map< K, V, H, E > &a, const std::unordered_map< K, V, H, E > &b)

template<typename T , typename U , typename = enable_if_t<std::is_base_of<Basic, T>::value and std::is_base_of<Basic, U>::value>>
bool	unified_eq (const RCP< const T > &a, const RCP< const U > &b)

template<typename T , typename = enable_if_t<std::is_arithmetic<T>::value or std::is_same<T, integer_class>::value>>
bool	unified_eq (const T &a, const T &b)

template<class T >
bool	unordered_eq (const T &a, const T &b)

template<class T >
bool	ordered_eq (const T &A, const T &B)

template<typename T >
bool	unified_eq (const std::vector< T > &a, const std::vector< T > &b)

template<typename T , typename = enable_if_t<std::is_arithmetic<T>::value or std::is_same<T, integer_class>::value or std::is_same<T, rational_class>::value>>
int	unified_compare (const T &a, const T &b)

template<typename T , typename U , typename = enable_if_t<std::is_base_of<Basic, T>::value and std::is_base_of<Basic, U>::value>>
int	unified_compare (const RCP< const T > &a, const RCP< const U > &b)

template<class T >
int	ordered_compare (const T &A, const T &B)

template<typename T >
int	unified_compare (const std::vector< T > &a, const std::vector< T > &b)

template<typename T , typename U >
int	unified_compare (const std::set< T, U > &a, const std::set< T, U > &b)

template<typename T , typename U >
int	unified_compare (const std::multiset< T, U > &a, const std::multiset< T, U > &b)

template<typename T , typename U >
int	unified_compare (const std::pair< T, U > &a, const std::pair< T, U > &b)

template<typename K , typename V , typename C >
int	unified_compare (const std::map< K, V, C > &a, const std::map< K, V, C > &b)

template<typename K , typename V , typename H , typename E >
int	unified_compare (const std::unordered_map< K, V, H, E > &a, const std::unordered_map< K, V, H, E > &b)

template<class M , typename C = std::less<typename M::key_type>>
int	unordered_compare (const M &a, const M &b)

bool	order (const DenseMatrix &t, const std::vector< DenseMatrix > &basis, unsigned k)

bool	is_minimum (const DenseMatrix &t, const std::vector< DenseMatrix > &basis, unsigned n)

void	homogeneous_lde (std::vector< DenseMatrix > &basis, const DenseMatrix &A)

RCP< const Number >	evalf_numeric (const Basic &b, unsigned long bits, bool real)

RCP< const Basic >	evalf (const Basic &b, unsigned long bits, EvalfDomain domain)

static std::vector< fn >	init_eval_double ()

double	eval_double (const Basic &b)

std::complex< double >	eval_complex_double (const Basic &b)

double	eval_double_single_dispatch (const Basic &b)

double	eval_double_visitor_pattern (const Basic &b)

RCP< const Number >	_mulnum (const RCP< const Number > &x, const RCP< const Number > &y)

void	_imulnum (const Ptr< RCP< const Number > > &self, const RCP< const Number > &other)

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

Expression	expand (const Expression &arg)

bool	unified_eq (const Expression &a, const Expression &b)

int	unified_compare (const Expression &a, const Expression &b)

RCP< const GaloisField >	gf_poly (RCP< const Basic > i, GaloisFieldDict &&dict)

RCP< const GaloisField >	gf_poly (RCP< const Basic > i, map_uint_mpz &&dict, integer_class modulo_)

RCP< const GaloisField >	pow_upoly (const GaloisField &a, unsigned int p)

vec_basic	generate_fdiff_weights_vector (const vec_basic &grid, const unsigned max_deriv, const RCP< const Basic > around)

RCP< const Basic >	sqrt (RCP< const Basic > &arg)

RCP< const Basic >	cbrt (RCP< const Basic > &arg)

static const RCP< const Basic > *	sin_table ()

static const umap_basic_basic &	inverse_cst ()

static const umap_basic_basic &	inverse_tct ()

RCP< const Basic >	conjugate (const RCP< const Basic > &arg)
	Canonicalize Conjugate.

bool	get_pi_shift (const RCP< const Basic > &arg, const Ptr< RCP< const Number > > &n, const Ptr< RCP< const Basic > > &x)

bool	trig_has_basic_shift (const RCP< const Basic > &arg)

bool	could_extract_minus (const Basic &arg)

bool	handle_minus (const RCP< const Basic > &arg, const Ptr< RCP< const Basic > > &rarg)

bool	trig_simplify (const RCP< const Basic > &arg, unsigned period, bool odd, bool conj_odd, const Ptr< RCP< const Basic > > &rarg, int &index, int &sign)

bool	inverse_lookup (const umap_basic_basic &d, const RCP< const Basic > &t, const Ptr< RCP< const Basic > > &index)

RCP< const Basic >	sign (const RCP< const Basic > &arg)
	Canonicalize Sign.

RCP< const Basic >	floor (const RCP< const Basic > &arg)
	Canonicalize Floor:

RCP< const Basic >	ceiling (const RCP< const Basic > &arg)
	Canonicalize Ceiling:

RCP< const Basic >	truncate (const RCP< const Basic > &arg)
	Canonicalize Truncate:

RCP< const Basic >	sin (const RCP< const Basic > &arg)
	Canonicalize Sin:

RCP< const Basic >	cos (const RCP< const Basic > &arg)
	Canonicalize Cos:

RCP< const Basic >	tan (const RCP< const Basic > &arg)
	Canonicalize Tan:

RCP< const Basic >	cot (const RCP< const Basic > &arg)
	Canonicalize Cot:

RCP< const Basic >	csc (const RCP< const Basic > &arg)
	Canonicalize Csc:

RCP< const Basic >	sec (const RCP< const Basic > &arg)
	Canonicalize Sec:

RCP< const Basic >	trig_to_sqrt (const RCP< const Basic > &arg)

RCP< const Basic >	asin (const RCP< const Basic > &arg)
	Canonicalize ASin:

RCP< const Basic >	acos (const RCP< const Basic > &arg)
	Canonicalize ACos:

RCP< const Basic >	asec (const RCP< const Basic > &arg)
	Canonicalize ASec:

RCP< const Basic >	acsc (const RCP< const Basic > &arg)
	Canonicalize ACsc:

RCP< const Basic >	atan (const RCP< const Basic > &arg)
	Canonicalize ATan:

RCP< const Basic >	acot (const RCP< const Basic > &arg)
	Canonicalize ACot:

RCP< const Basic >	atan2 (const RCP< const Basic > &num, const RCP< const Basic > &den)
	Canonicalize ATan2:

RCP< const Basic >	log (const RCP< const Basic > &arg)
	Returns the Natural Logarithm from argument `arg`

RCP< const Basic >	log (const RCP< const Basic > &arg, const RCP< const Basic > &base)

RCP< const Basic >	lambertw (const RCP< const Basic > &arg)
	Create a new LambertW instance:

RCP< const Basic >	function_symbol (std::string name, const vec_basic &arg)

RCP< const Basic >	function_symbol (std::string name, const RCP< const Basic > &arg)
	Create a new FunctionSymbol instance:

RCP< const Basic >	sinh (const RCP< const Basic > &arg)
	Canonicalize Sinh:

RCP< const Basic >	csch (const RCP< const Basic > &arg)
	Canonicalize Csch:

RCP< const Basic >	cosh (const RCP< const Basic > &arg)
	Canonicalize Cosh:

RCP< const Basic >	sech (const RCP< const Basic > &arg)
	Canonicalize Sech:

RCP< const Basic >	tanh (const RCP< const Basic > &arg)
	Canonicalize Tanh:

RCP< const Basic >	coth (const RCP< const Basic > &arg)
	Canonicalize Coth:

RCP< const Basic >	asinh (const RCP< const Basic > &arg)
	Canonicalize ASinh:

RCP< const Basic >	acsch (const RCP< const Basic > &arg)
	Canonicalize ACsch:

RCP< const Basic >	acosh (const RCP< const Basic > &arg)
	Canonicalize ACosh:

RCP< const Basic >	atanh (const RCP< const Basic > &arg)
	Canonicalize ATanh:

RCP< const Basic >	acoth (const RCP< const Basic > &arg)
	Canonicalize ACoth:

RCP< const Basic >	asech (const RCP< const Basic > &arg)
	Canonicalize ASech:

RCP< const Basic >	kronecker_delta (const RCP< const Basic > &i, const RCP< const Basic > &j)
	Canonicalize KroneckerDelta:

bool	has_dup (const vec_basic &arg)

RCP< const Basic >	eval_levicivita (const vec_basic &arg, int len)

RCP< const Basic >	levi_civita (const vec_basic &arg)
	Canonicalize LeviCivita:

RCP< const Basic >	zeta (const RCP< const Basic > &s, const RCP< const Basic > &a)
	Create a new Zeta instance:

RCP< const Basic >	zeta (const RCP< const Basic > &s)

RCP< const Basic >	dirichlet_eta (const RCP< const Basic > &s)
	Create a new Dirichlet_eta instance:

RCP< const Basic >	erf (const RCP< const Basic > &arg)
	Canonicalize Erf:

RCP< const Basic >	erfc (const RCP< const Basic > &arg)
	Canonicalize Erfc:

RCP< const Basic >	gamma_positive_int (const RCP< const Basic > &arg)

RCP< const Basic >	gamma_multiple_2 (const RCP< const Basic > &arg)

RCP< const Basic >	gamma (const RCP< const Basic > &arg)
	Canonicalize Gamma:

RCP< const Basic >	lowergamma (const RCP< const Basic > &s, const RCP< const Basic > &x)
	Canonicalize LowerGamma:

RCP< const Basic >	uppergamma (const RCP< const Basic > &s, const RCP< const Basic > &x)
	Canonicalize UpperGamma:

RCP< const Basic >	loggamma (const RCP< const Basic > &arg)
	Canonicalize LogGamma:

RCP< const Basic >	beta (const RCP< const Basic > &x, const RCP< const Basic > &y)
	Canonicalize Beta:

RCP< const Basic >	polygamma (const RCP< const Basic > &n, const RCP< const Basic > &x)
	Canonicalize PolyGamma.

RCP< const Basic >	digamma (const RCP< const Basic > &x)

RCP< const Basic >	trigamma (const RCP< const Basic > &x)

RCP< const Basic >	abs (const RCP< const Basic > &arg)
	Canonicalize Abs:

RCP< const Basic >	max (const vec_basic &arg)
	Canonicalize Max:

RCP< const Basic >	min (const vec_basic &arg)
	Canonicalize Min:

RCP< const Basic >	unevaluated_expr (const RCP< const Basic > &arg)

RCP< const Basic >	sqrt (const RCP< const Basic > &arg)

RCP< const Basic >	cbrt (const RCP< const Basic > &arg)

RCP< const Infty >	infty (const RCP< const Number > &direction)

RCP< const Infty >	infty (int n=1)

RCP< const Integer >	isqrt (const Integer &n)
	Integer Square root.

RCP< const Integer >	iabs (const Integer &n)
	Integer Absolute value.

int	i_nth_root (const Ptr< RCP< const Integer > > &r, const Integer &a, unsigned long int n)
	Integer nth root.

bool	perfect_square (const Integer &n)
	Perfect Square.

bool	perfect_power (const Integer &n)
	Perfect Square.

template<typename T >
std::enable_if< std::is_integral< T >::value, RCP< constInteger > >::type	integer (T i)

RCP< const Integer >	integer (integer_class i)

llvm::Function *	get_float_intrinsic (llvm::Type type, llvm::Intrinsic::ID id, unsigned n, llvm::Module mod)

RCP< const Boolean >	contains (const RCP< const Basic > &expr, const RCP< const Set > &set)

RCP< const Basic >	piecewise (const PiecewiseVec &vec)

const vec_boolean	get_vec_from_set (const set_boolean &s)

template<typename caller >
RCP< const Boolean >	and_or (const set_boolean &s, const bool &op_x_notx)

RCP< const Boolean >	logical_not (const RCP< const Boolean > &s)

RCP< const Boolean >	logical_xor (const vec_boolean &s)

RCP< const Boolean >	Eq (const RCP< const Basic > &lhs)
	Returns the canonicalized Equality object from a single argument.

RCP< const Boolean >	Eq (const RCP< const Basic > &lhs, const RCP< const Basic > &rhs)
	Returns the canonicalized Equality object from the two arguments.

RCP< const Boolean >	Ne (const RCP< const Basic > &lhs, const RCP< const Basic > &rhs)
	Returns the canonicalized Unequality object from the arguments.

RCP< const Boolean >	Le (const RCP< const Basic > &lhs, const RCP< const Basic > &rhs)
	Returns the canonicalized LessThan object from the arguments.

RCP< const Boolean >	Ge (const RCP< const Basic > &lhs, const RCP< const Basic > &rhs)
	Convenience function returning LessThan object.

RCP< const Boolean >	Lt (const RCP< const Basic > &lhs, const RCP< const Basic > &rhs)
	Returns the canonicalized StrictLessThan object from the arguments.

RCP< const Boolean >	Gt (const RCP< const Basic > &lhs, const RCP< const Basic > &rhs)
	Convenience function returning StrictLessThan object.

RCP< const Boolean >	logical_and (const set_boolean &s)

RCP< const Boolean >	logical_nand (const set_boolean &s)

RCP< const Boolean >	logical_or (const set_boolean &s)

RCP< const Boolean >	logical_nor (const set_boolean &s)

RCP< const Boolean >	logical_xnor (const vec_boolean &s)

RCP< const BooleanAtom >	boolean (bool b)

bool	is_a_Relational (const Basic &b)

bool	is_a_Boolean (const Basic &b)

RCP< const MatrixExpr >	conjugate_matrix (const RCP< const MatrixExpr > &arg)

bool	is_zero_vec (const vec_basic &container)

bool	is_identity_vec (const vec_basic &container)

RCP< const MatrixExpr >	diagonal_matrix (const vec_basic &container)

void	check_matching_sizes (const vec_basic &vec)

RCP< const MatrixExpr >	hadamard_product (const vec_basic &factors)

RCP< const MatrixExpr >	identity_matrix (const RCP< const Basic > &n)

bool	is_identity_dense (size_t n, const vec_basic &container)

bool	is_diagonal_dense (size_t n, const vec_basic &container)

vec_basic	extract_diagonal (size_t n, const vec_basic &container)

RCP< const MatrixExpr >	immutable_dense_matrix (size_t m, size_t n, const vec_basic &container)

tribool	is_diagonal (const MatrixExpr &m, const Assumptions *assumptions)

tribool	is_lower (const MatrixExpr &m, const Assumptions *assumptions)

tribool	is_real (const MatrixExpr &m, const Assumptions *assumptions)

tribool	is_square (const MatrixExpr &m, const Assumptions *assumptions)

tribool	is_symmetric (const MatrixExpr &m, const Assumptions *assumptions)

tribool	is_toeplitz (const MatrixExpr &m, const Assumptions *assumptions)

tribool	is_upper (const MatrixExpr &m, const Assumptions *assumptions)

tribool	is_zero (const MatrixExpr &m, const Assumptions *assumptions)

RCP< const MatrixExpr >	matrix_add (const vec_basic &terms)

bool	is_a_MatrixExpr (const Basic &b)

RCP< const DiagonalMatrix >	mul_diag_diag (const DiagonalMatrix &A, const DiagonalMatrix &B)

RCP< const ImmutableDenseMatrix >	mul_dense_dense (const ImmutableDenseMatrix &A, const ImmutableDenseMatrix &B)

RCP< const ImmutableDenseMatrix >	mul_diag_dense (const DiagonalMatrix &A, const ImmutableDenseMatrix &B)

RCP< const ImmutableDenseMatrix >	mul_dense_diag (const ImmutableDenseMatrix &A, const DiagonalMatrix &B)

void	check_matching_mul_sizes (const vec_basic &vec)

RCP< const MatrixExpr >	matrix_mul (const vec_basic &factors)

RCP< const MatrixExpr >	matrix_symbol (const std::string &name)

std::pair< RCP< const Basic >, RCP< const Basic > >	size (const MatrixExpr &m)

RCP< const Basic >	trace (const RCP< const MatrixExpr > &arg)

RCP< const MatrixExpr >	transpose (const RCP< const MatrixExpr > &arg)

RCP< const MatrixExpr >	zero_matrix (const RCP< const Basic > &m, const RCP< const Basic > &n)

template<class T >
bool	is_a (const MatrixBase &b)

bool	operator== (const SymEngine::MatrixBase &lhs, const SymEngine::MatrixBase &rhs)

bool	operator!= (const SymEngine::MatrixBase &lhs, const SymEngine::MatrixBase &rhs)

void	monomial_mul (const vec_int &A, const vec_int &B, vec_int &C)
	Monomial multiplication.

integer_class	pow (const integer_class &a, unsigned long b)

void	mp_fdiv_qr (integer_class &q, integer_class &r, const integer_class &a, const integer_class &b)

void	mp_cdiv_qr (integer_class &q, integer_class &r, const integer_class &a, const integer_class &b)

void	mp_gcdext (integer_class &gcd, integer_class &s, integer_class &t, const integer_class &a, const integer_class &b)

bool	mp_invert (integer_class &res, const integer_class &a, const integer_class &m)

integer_class	fmod (const integer_class &a, const integer_class &mod)

void	mp_pow_ui (rational_class &res, const rational_class &i, unsigned long n)

void	mp_powm (integer_class &res, const integer_class &base, const integer_class &exp, const integer_class &m)

integer_class	step (const unsigned long &n, const integer_class &i, integer_class &x)

bool	positive_root (integer_class &res, const integer_class &i, const unsigned long n)

bool	mp_root (integer_class &res, const integer_class &i, const unsigned long n)

integer_class	mp_sqrt (const integer_class &i)

void	mp_rootrem (integer_class &a, integer_class &b, const integer_class &i, unsigned long n)

void	mp_sqrtrem (integer_class &a, integer_class &b, const integer_class &i)

int	mp_probab_prime_p (const integer_class &i, unsigned retries)

void	mp_nextprime (integer_class &res, const integer_class &i)

unsigned long	mp_scan1 (const integer_class &i)

two_by_two_matrix	fib_matrix (unsigned long n)

void	mp_fib_ui (integer_class &res, unsigned long n)

void	mp_fib2_ui (integer_class &a, integer_class &b, unsigned long n)

two_by_two_matrix	luc_matrix (unsigned long n)

void	mp_lucnum_ui (integer_class &res, unsigned long n)

void	mp_lucnum2_ui (integer_class &a, integer_class &b, unsigned long n)

void	mp_fac_ui (integer_class &res, unsigned long n)

void	mp_bin_ui (integer_class &res, const integer_class &n, unsigned long r)

bool	mp_perfect_power_p (const integer_class &i)

bool	mp_perfect_square_p (const integer_class &i)

integer_class	mp_primorial (unsigned long n)

int	mp_legendre (const integer_class &a, const integer_class &n)

int	unchecked_jacobi (const integer_class &a, const integer_class &n)

int	mp_jacobi (const integer_class &a, const integer_class &n)

int	mp_kronecker (const integer_class &a, const integer_class &n)

integer_class	operator""_z (const char *str)
	Literal for creating multiple precision integers.

rational_class	operator""_q (const char *str)

integer_class	mp_abs (const integer_class &i)

int	mp_sign (const integer_class &i)

double	mp_get_d (const integer_class &i)

void	mp_set_d (integer_class &i, double a)

void	mp_set_str (integer_class &i, const std::string &a)

std::string	mp_get_hex_str (const integer_class &i)

void	mp_demote (integer_class &i)

bool	mp_fits_ulong_p (const integer_class &i)

bool	mp_fits_slong_p (const integer_class &i)

unsigned long	mp_get_ui (const integer_class &i)

long	mp_get_si (const integer_class &i)

mpz_srcptr	get_mpz_t (const integer_class &i)

mpz_ptr	get_mpz_t (integer_class &i)

void	mp_pow_ui (integer_class &res, const integer_class &i, unsigned long n)

void	mp_gcd (integer_class &res, const integer_class &a, const integer_class &b)

void	mp_and (integer_class &res, const integer_class &a, const integer_class &b)

void	mp_fdiv_r (integer_class &res, const integer_class &a, const integer_class &b)

void	mp_fdiv_q (integer_class &res, const integer_class &a, const integer_class &b)

void	mp_cdiv_q (integer_class &res, const integer_class &a, const integer_class &b)

void	mp_tdiv_q (integer_class &res, const integer_class &a, const integer_class &b)

void	mp_divexact (integer_class &q, const integer_class &a, const integer_class &b)

void	mp_lcm (integer_class &q, const integer_class &a, const integer_class &b)

void	mp_tdiv_qr (integer_class &q, integer_class &r, const integer_class &a, const integer_class &b)

void	mp_addmul (integer_class &r, const integer_class &a, const integer_class &b)

const integer_class &	get_den (const rational_class &i)

const integer_class &	get_num (const rational_class &i)

integer_class &	get_den (rational_class &i)

integer_class &	get_num (rational_class &i)

mpq_srcptr	get_mpq_t (const rational_class &i)

void	canonicalize (rational_class &i)

double	mp_get_d (const rational_class &i)

int	mp_sign (const rational_class &i)

rational_class	mp_abs (const rational_class &i)

bool	mp_divisible_p (const integer_class &a, const integer_class &b)

void	mp_urandomm (integer_class &a, gmp_randstate_t &t, const integer_class &b)

auto	get_mp_t (const integer_class &x) -> decltype(get_mpz_t(x))

auto	get_mp_t (const rational_class &x) -> decltype(get_mpq_t(x))

int	mp_cmpabs (const integer_class &a, const integer_class &b)

std::ostream &	operator<< (std::ostream &os, const fmpz_wrapper &f)

std::ostream &	operator<< (std::ostream &os, const fmpq_wrapper &f)

RCP< const Basic >	mul (const RCP< const Basic > &a, const RCP< const Basic > &b)
	Multiplication.

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

RCP< const Basic >	div (const RCP< const Basic > &a, const RCP< const Basic > &b)
	Division.

RCP< const Basic >	neg (const RCP< const Basic > &a)
	Negation.

RCP< const Integer >	gcd (const Integer &a, const Integer &b)
	Greatest Common Divisor.

void	gcd_ext (const Ptr< RCP< const Integer > > &g, const Ptr< RCP< const Integer > > &s, const Ptr< RCP< const Integer > > &t, const Integer &a, const Integer &b)
	Extended GCD.

RCP< const Integer >	lcm (const Integer &a, const Integer &b)
	Least Common Multiple.

int	mod_inverse (const Ptr< RCP< const Integer > > &b, const Integer &a, const Integer &m)
	inverse modulo

RCP< const Integer >	mod (const Integer &n, const Integer &d)
	modulo round toward zero

RCP< const Integer >	quotient (const Integer &n, const Integer &d)

void	quotient_mod (const Ptr< RCP< const Integer > > &q, const Ptr< RCP< const Integer > > &r, const Integer &n, const Integer &d)

RCP< const Integer >	mod_f (const Integer &n, const Integer &d)
	modulo round toward -inf

RCP< const Integer >	quotient_f (const Integer &n, const Integer &d)

void	quotient_mod_f (const Ptr< RCP< const Integer > > &q, const Ptr< RCP< const Integer > > &r, const Integer &n, const Integer &d)

RCP< const Integer >	fibonacci (unsigned long n)
	Fibonacci number.

void	fibonacci2 (const Ptr< RCP< const Integer > > &g, const Ptr< RCP< const Integer > > &s, unsigned long n)
	Fibonacci n and n-1.

RCP< const Integer >	lucas (unsigned long n)
	Lucas number.

void	lucas2 (const Ptr< RCP< const Integer > > &g, const Ptr< RCP< const Integer > > &s, unsigned long n)
	Lucas number n and n-1.

RCP< const Integer >	binomial (const Integer &n, unsigned long k)
	Binomial Coefficient.

RCP< const Integer >	factorial (unsigned long n)
	Factorial.

bool	divides (const Integer &a, const Integer &b)

int	probab_prime_p (const Integer &a, unsigned reps=25)
	Probabilistic Prime.

RCP< const Integer >	nextprime (const Integer &a)

int	factor_lehman_method (const Ptr< RCP< const Integer > > &f, const Integer &n)
	Factor using lehman's methods.

int	factor_pollard_pm1_method (const Ptr< RCP< const Integer > > &f, const Integer &n, unsigned B=10, unsigned retries=5)
	Factor using Pollard's p-1 method.

int	factor_pollard_rho_method (const Ptr< RCP< const Integer > > &f, const Integer &n, unsigned retries=5)
	Factor using Pollard's rho methods.

int	factor (const Ptr< RCP< const Integer > > &f, const Integer &n, double B1)

int	factor_trial_division (const Ptr< RCP< const Integer > > &f, const Integer &n)

void	prime_factors (std::vector< RCP< const Integer > > &primes, const Integer &n)
	Find prime factors of `n`

void	prime_factor_multiplicities (map_integer_uint &primes, const Integer &n)
	Find multiplicities of prime factors of `n`

RCP< const Number >	bernoulli (unsigned long n)

RCP< const Number >	harmonic (unsigned long n, long m=1)
	Computes the sum of the inverses of the first perfect mth powers.

bool	crt (const Ptr< RCP< const Integer > > &R, const std::vector< RCP< const Integer > > &rem, const std::vector< RCP< const Integer > > &mod)
	Chinese remainder function. Return true when a solution exists.

bool	primitive_root (const Ptr< RCP< const Integer > > &g, const Integer &n)
	Computes a primitive root. Returns false if no primitive root exists.

void	primitive_root_list (std::vector< RCP< const Integer > > &roots, const Integer &n)

RCP< const Integer >	totient (const RCP< const Integer > &n)
	Euler's totient function.

RCP< const Integer >	carmichael (const RCP< const Integer > &n)
	Carmichael function.

bool	multiplicative_order (const Ptr< RCP< const Integer > > &o, const RCP< const Integer > &a, const RCP< const Integer > &n)
	Multiplicative order. Return false if order does not exist.

int	legendre (const Integer &a, const Integer &n)
	Legendre Function.

int	jacobi (const Integer &a, const Integer &n)
	Jacobi Function.

int	kronecker (const Integer &a, const Integer &n)
	Kronecker Function.

bool	_is_nthroot_mod_prime_power (const integer_class &a, const integer_class &n, const integer_class &p, const unsigned k)

bool	nthroot_mod (const Ptr< RCP< const Integer > > &root, const RCP< const Integer > &a, const RCP< const Integer > &n, const RCP< const Integer > &m)
	A solution to x**n == a mod m. Return false if none exists.

void	nthroot_mod_list (std::vector< RCP< const Integer > > &roots, const RCP< const Integer > &a, const RCP< const Integer > &n, const RCP< const Integer > &m)
	All Solutions to x**n == a mod m. Return false if none exists.

bool	powermod (const Ptr< RCP< const Integer > > &powm, const RCP< const Integer > &a, const RCP< const Number > &b, const RCP< const Integer > &m)

void	powermod_list (std::vector< RCP< const Integer > > &pows, const RCP< const Integer > &a, const RCP< const Number > &b, const RCP< const Integer > &m)

vec_integer_class	quadratic_residues (const Integer &a)
	Finds all Quadratic Residues of a Positive Integer.

bool	is_quad_residue (const Integer &a, const Integer &p)
	Returns true if 'a' is a quadratic residue of 'p'.

bool	is_nth_residue (const Integer &a, const Integer &n, const Integer &mod)
	Returns true if 'a' is a nth power residue of 'mod'.

int	mobius (const Integer &a)
	Mobius Function.

long	mertens (const unsigned long a)

integer_class	mp_polygonal_number (const integer_class &s, const integer_class &n)
	Numeric calculation of the n:th s-gonal number.

integer_class	mp_principal_polygonal_root (const integer_class &s, const integer_class &x)
	Numeric calculation of the principal s-gonal root of x.

std::pair< integer_class, integer_class >	mp_perfect_power_decomposition (const integer_class &n, bool lowest_exponent=false)
	Decompose a positive integer into perfect powers.

RCP< const Basic >	primepi (const RCP< const Basic > &arg)

RCP< const Basic >	primorial (const RCP< const Basic > &arg)

RCP< const Basic >	polygonal_number (const RCP< const Basic > &s, const RCP< const Basic > &n)
	The n:th s-gonal number.

RCP< const Basic >	principal_polygonal_root (const RCP< const Basic > &s, const RCP< const Basic > &x)
	The principal s-gonal root of x.

RCP< const Number >	addnum (const RCP< const Number > &self, const RCP< const Number > &other)
	Add `self` and `other`

RCP< const Number >	subnum (const RCP< const Number > &self, const RCP< const Number > &other)
	Subtract `self` and `other`

RCP< const Number >	mulnum (const RCP< const Number > &self, const RCP< const Number > &other)
	Multiply `self` and `other`

RCP< const Number >	divnum (const RCP< const Number > &self, const RCP< const Number > &other)
	Divide `self` and `other`

RCP< const Number >	pownum (const RCP< const Number > &self, const RCP< const Number > &other)
	Raise `self` to power `other`

void	iaddnum (const Ptr< RCP< const Number > > &self, const RCP< const Number > &other)

void	imulnum (const Ptr< RCP< const Number > > &self, const RCP< const Number > &other)

void	idivnum (const Ptr< RCP< const Number > > &self, const RCP< const Number > &other)

bool	is_a_Number (const Basic &b)

bool	is_number_and_zero (const Basic &b)

tribool	is_zero (const Basic &b, const Assumptions *assumptions=nullptr)
	Check if a number is zero.

tribool	is_nonzero (const Basic &b, const Assumptions *assumptions=nullptr)
	Check if a number is non-zero.

tribool	is_positive (const Basic &b, const Assumptions *assumptions=nullptr)

tribool	is_nonpositive (const Basic &b, const Assumptions *assumptions=nullptr)

tribool	is_negative (const Basic &b, const Assumptions *assumptions=nullptr)

tribool	is_nonnegative (const Basic &b, const Assumptions *assumptions=nullptr)

tribool	is_integer (const Basic &b, const Assumptions *assumptions=nullptr)

tribool	is_real (const Basic &b, const Assumptions *assumptions=nullptr)

tribool	is_complex (const Basic &b, const Assumptions *assumptions=nullptr)

tribool	is_rational (const Basic &b)

tribool	is_irrational (const Basic &b)

tribool	is_finite (const Basic &b, const Assumptions *assumptions=nullptr)

tribool	is_infinite (const Basic &b, const Assumptions *assumptions=nullptr)

tribool	is_even (const Basic &b, const Assumptions *assumptions=nullptr)

tribool	is_odd (const Basic &b, const Assumptions *assumptions=nullptr)

tribool	is_algebraic (const Basic &b, const Assumptions *assumptions=nullptr)

tribool	is_transcendental (const Basic &b, const Assumptions *assumptions=nullptr)

RCP< const Basic >	parse (const std::string &s, bool convert_xor=true, const std::map< const std::string, const RCP< const Basic > > &constants={})

RCP< const Basic >	parse_old (const std::string &s, bool convert_xor=true)

RCP< const Basic >	parse_sbml (const std::string &s, const std::map< const std::string, const RCP< const Basic > > &constants={})

umap_basic_num	_find_gens_poly_pow (const RCP< const Basic > &x, const RCP< const Basic > &base)

umap_basic_num	_find_gens_poly (const RCP< const Basic > &x)

template<typename P >
RCP< const P >	from_basic (const RCP< const Basic > &basic, const RCP< const Basic > &gen, bool ex=false)

template<typename P >
enable_if_t< is_a_UPoly< P >::value, RCP< const P > >	from_basic (const RCP< const Basic > &basic, bool ex=false)

template<typename T , typename P >
enable_if_t< std::is_same< T, UExprDict >::value, T >	_basic_to_upoly (const RCP< const Basic > &basic, const RCP< const Basic > &gen)

template<typename T , typename P >
enable_if_t< std::is_base_of< UIntPolyBase< T, P >, P >::value, T >	_basic_to_upoly (const RCP< const Basic > &basic, const RCP< const Basic > &gen)

template<typename T , typename P >
enable_if_t< std::is_base_of< URatPolyBase< T, P >, P >::value, T >	_basic_to_upoly (const RCP< const Basic > &basic, const RCP< const Basic > &gen)

template<typename P >
enable_if_t< std::is_same< MIntPoly, P >::value, typename P::container_type >	_basic_to_mpoly (const RCP< const Basic > &basic, const set_basic &gens)

template<typename P >
enable_if_t< std::is_same< MExprPoly, P >::value, typename P::container_type >	_basic_to_mpoly (const RCP< const Basic > &basic, const set_basic &gens)

template<typename P >
RCP< const P >	from_basic (const RCP< const Basic > &basic, set_basic &gens, bool ex=false)

template<typename P >
enable_if_t< std::is_base_of< MSymEnginePoly< typename P::container_type, P >, P >::value, RCP< const P > >	from_basic (const RCP< const Basic > &basic, bool ex=false)

template<typename Poly >
void	cancel (const RCP< const Basic > &numer, const RCP< const Basic > &denom, const Ptr< RCP< const Poly > > &result_numer, const Ptr< RCP< const Poly > > &result_denom, const Ptr< RCP< const Poly > > &common)

unsigned int	reconcile (vec_uint &v1, vec_uint &v2, set_basic &s, const set_basic &s1, const set_basic &s2)

template<typename Poly , typename Container >
set_basic	get_translated_container (Container &x, Container &y, const Poly &a, const Poly &b)

template<typename Poly >
RCP< const Poly >	add_mpoly (const Poly &a, const Poly &b)

template<typename Poly >
RCP< const Poly >	sub_mpoly (const Poly &a, const Poly &b)

template<typename Poly >
RCP< const Poly >	mul_mpoly (const Poly &a, const Poly &b)

template<typename Poly >
RCP< const Poly >	neg_mpoly (const Poly &a)

template<typename Poly >
RCP< const Poly >	pow_mpoly (const Poly &a, unsigned int n)

RCP< const UExprPoly >	uexpr_poly (RCP< const Basic > i, UExprDict &&dict)

RCP< const UExprPoly >	uexpr_poly (RCP< const Basic > i, map_int_Expr &&dict)

bool	divides_upoly (const UIntPoly &a, const UIntPoly &b, const Ptr< RCP< const UIntPoly > > &out)

template<typename T >
unsigned int	bit_length (T t)

integer_class	to_mp_class (const integer_class &i)

rational_class	to_mp_class (const rational_class &i)

template<typename Poly >
RCP< const Poly >	add_upoly (const Poly &a, const Poly &b)

template<typename Poly >
RCP< const Poly >	neg_upoly (const Poly &a)

template<typename Poly >
RCP< const Poly >	sub_upoly (const Poly &a, const Poly &b)

template<typename Poly >
RCP< const Poly >	mul_upoly (const Poly &a, const Poly &b)

template<typename Poly >
RCP< const Poly >	quo_upoly (const Poly &a, const Poly &b)

bool	divides_upoly (const URatPoly &a, const URatPoly &b, const Ptr< RCP< const URatPoly > > &out)

template<typename Container , template< typename X, typename Y > class BaseType, typename Poly >
RCP< const Poly >	pow_upoly (const USymEnginePoly< Container, BaseType, Poly > &a, unsigned int p)

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

void	multinomial_coefficients (unsigned m, unsigned n, map_vec_uint &r)

void	multinomial_coefficients_mpz (unsigned m, unsigned n, map_vec_mpz &r)

RCP< const Basic >	exp (const RCP< const Basic > &x)
	Returns the natural exponential function `E**x = pow(E, x)`

RCP< const Basic >	pow_expand (const RCP< const Pow > &self)
	Expand the power expression.

static std::vector< unsigned > &	sieve_primes ()

std::string	str (const Basic &x)

std::string	str (const DenseMatrix &x)

std::string	unicode (const Basic &x)

std::string	julia_str (const Basic &x)

std::string	sbml (const Basic &x)

std::string	ascii_art ()

std::string	mathml (const Basic &x)

std::string	latex (const Basic &x)

std::string	latex (const DenseMatrix &x, const unsigned max_rows=20, const unsigned max_cols=12)

std::string	ccode (const Basic &x)

std::string	c89code (const Basic &x)

std::string	c99code (const Basic &x)

std::string	jscode (const Basic &x)

void	print_rational_class (const rational_class &r, std::ostringstream &s)

std::vector< std::string >	init_latex_printer_names ()

std::vector< std::string >	init_mathml_printer_names ()

static std::vector< std::string >	init_sbml_printer_names ()

std::string	print_double (double d)

template<typename T >
char	_print_sign (const T &i)

template<typename P >
std::string	upoly_print (const P &x)

std::vector< std::string >	init_str_printer_names ()

static std::vector< std::string >	init_unicode_printer_names ()

static std::vector< size_t >	init_unicode_printer_lengths (const std::vector< std::string > &names)

void	get_num_den (const Rational &rat, const Ptr< RCP< const Integer > > &num, const Ptr< RCP< const Integer > > &den)
	returns the `num` and `den` of rational `rat` as `RCP<const Integer>`

RCP< const Number >	rational (long n, long d)
	convenience creator from two longs

RCP< const RealDouble >	real_double (double x)

RCP< const Number >	number (std::complex< double > x)

RCP< const Number >	number (double x)

RCP< const Basic >	refine (const RCP< const Basic > &x, const Assumptions *assumptions)

void	expr2poly (const RCP< const Basic > &p, umap_basic_num &syms, umap_vec_mpz &P)
	Converts expression `p` into a polynomial `P`, with symbols `sym`

void	poly_mul (const umap_vec_mpz &A, const umap_vec_mpz &B, umap_vec_mpz &C)
	Multiply two polynomials: `C = A*B`

template<class Archive >
void	save_basic (Archive &ar, const Basic &b)

template<class Archive >
void	save_basic (Archive &ar, const Symbol &b)

template<class Archive >
void	save_basic (Archive &ar, const Mul &b)

template<class Archive >
void	save_basic (Archive &ar, const Add &b)

template<class Archive >
void	save_basic (Archive &ar, const Pow &b)

template<typename Archive >
void	save_helper (Archive &ar, const integer_class &intgr)

template<typename Archive >
void	save_helper (Archive &ar, const rational_class &rat)

template<typename Archive >
void	save_basic (Archive &ar, const URatPoly &b)

template<class Archive >
void	save_basic (Archive &ar, const Integer &b)

template<class Archive >
void	save_basic (Archive &ar, const RealDouble &b)

template<class Archive >
void	save_basic (Archive &ar, const Rational &b)

template<class Archive >
void	save_basic (Archive &ar, const ComplexBase &b)

template<class Archive >
void	save_basic (Archive &ar, const Interval &b)

template<class Archive >
void	save_basic (Archive &ar, const BooleanAtom &b)

template<class Archive >
void	save_basic (Archive &ar, const Infty &b)

template<class Archive >
void	save_basic (Archive &ar, const NaN &b)

template<class Archive >
void	save_basic (Archive &ar, const Constant &b)

template<class Archive >
void	save_basic (Archive &ar, const OneArgFunction &b)

template<class Archive >
void	save_basic (Archive &ar, const TwoArgFunction &b)

template<class Archive >
void	save_basic (Archive &ar, const Relational &b)

template<class Archive >
void	save_basic (Archive &ar, const And &b)

template<class Archive >
void	save_basic (Archive &ar, const Or &b)

template<class Archive >
void	save_basic (Archive &ar, const Xor &b)

template<class Archive >
void	save_basic (Archive &ar, const Not &b)

template<class Archive >
void	save_basic (Archive &ar, const Contains &b)

template<class Archive >
void	save_basic (Archive &ar, const Piecewise &b)

template<class Archive >
void	save_basic (Archive &ar, const Reals &b)

template<class Archive >
void	save_basic (Archive &ar, const Rationals &b)

template<class Archive >
void	save_basic (Archive &ar, const EmptySet &b)

template<class Archive >
void	save_basic (Archive &ar, const Integers &b)

template<class Archive >
void	save_basic (Archive &ar, const UniversalSet &b)

template<class Archive >
void	save_basic (Archive &ar, const Union &b)

template<class Archive >
void	save_basic (Archive &ar, const Complement &b)

template<class Archive >
void	save_basic (Archive &ar, const ImageSet &b)

template<class Archive >
void	save_basic (Archive &ar, const FiniteSet &b)

template<class Archive >
void	save_basic (Archive &ar, const ConditionSet &b)

template<class Archive >
void	save_basic (Archive &ar, const GaloisField &b)

template<class Archive >
void	save_basic (Archive &ar, const SeriesCoeffInterface &)

template<class Archive >
void	save_basic (Archive &ar, const MultiArgFunction &b)

template<class Archive >
void	save_basic (Archive &ar, const FunctionSymbol &b)

template<class Archive >
void	save_basic (Archive &ar, const Derivative &b)

template<class Archive >
void	save_basic (Archive &ar, const Subs &b)

template<class Archive >
void	save_basic (Archive &ar, const NumberWrapper &b)

template<class Archive >
void	save_basic (Archive &ar, const FunctionWrapper &b)

template<class Archive >
void	save_basic (Archive &ar, RCP< const Basic > const &ptr)

template<class Archive , class T >
void	CEREAL_SAVE_FUNCTION_NAME (Archive &ar, RCP< const T > const &ptr)
	Saving for SymEngine::RCP.

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const RealDouble > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Infty > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const NaN > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Symbol > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Mul > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Add > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Pow > &)

template<typename Archive >
void	load_helper (Archive &ar, integer_class &intgr)

template<typename Archive >
void	load_helper (Archive &ar, const rational_class &rat)

template<typename Archive >
RCP< const Basic >	load_basic (Archive &ar, const URatPoly &b)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Integer > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Constant > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Rational > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Complex > &)

template<class Archive , class T >
RCP< const Basic >	load_basic (Archive &ar, RCP< const T > &, typename std::enable_if< std::is_base_of< ComplexBase, T >::value, int >::type *=nullptr)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Interval > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const BooleanAtom > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const And > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Or > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Xor > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Not > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Piecewise > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Contains > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Reals > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Rationals > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const EmptySet > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Integers > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const UniversalSet > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Union > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Complement > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const ImageSet > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const FiniteSet > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const ConditionSet > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Derivative > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const Subs > &)

template<class Archive , class T >
RCP< const Basic >	load_basic (Archive &ar, RCP< const T > &, typename std::enable_if< std::is_base_of< OneArgFunction, T >::value, int >::type *=nullptr)

template<class Archive , class T >
RCP< const Basic >	load_basic (Archive &ar, RCP< const T > &, typename std::enable_if< std::is_base_of< TwoArgFunction, T >::value, int >::type *=nullptr)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const FunctionSymbol > &)

template<class Archive >
RCP< const Basic >	load_basic (Archive &ar, RCP< const FunctionWrapper > &)

template<class Archive , class T >
RCP< const Basic >	load_basic (Archive &ar, RCP< const T > &, typename std::enable_if< std::is_base_of< MultiArgFunction, T >::value, int >::type *=nullptr)

template<class Archive , class T >
RCP< const Basic >	load_basic (Archive &ar, RCP< const T > &, typename std::enable_if< std::is_base_of< Relational, T >::value, int >::type *=nullptr)

template<class Archive , class T >
RCP< const Basic >	load_basic (Archive &ar, RCP< const T > &, typename std::enable_if< not(std::is_base_of< Relational, T >::value or std::is_base_of< ComplexBase, T >::value or std::is_base_of< OneArgFunction, T >::value or std::is_base_of< MultiArgFunction, T >::value or std::is_base_of< TwoArgFunction, T >::value), int >::type *=nullptr)

template<class Archive , class T >
void	CEREAL_LOAD_FUNCTION_NAME (Archive &ar, RCP< const T > &ptr)
	Loading for SymEngine::RCP.

bool	needs_symbolic_constants (const RCP< const Basic > &ex, const RCP< const Symbol > &var)

RCP< const SeriesCoeffInterface >	series (const RCP< const Basic > &ex, const RCP< const Symbol > &var, unsigned int prec)

RCP< const SeriesCoeffInterface >	series_invfunc (const RCP< const Basic > &ex, const RCP< const Symbol > &var, unsigned int prec)

RCP< const UnivariateSeries >	univariate_series (RCP< const Symbol > i, unsigned int prec, const UExprDict &s)

RCP< const Basic >	sup (const Set &s)

RCP< const Basic >	inf (const Set &s)

RCP< const Set >	boundary (const Set &s)

RCP< const Set >	interior (const Set &s)

RCP< const Set >	closure (const Set &s)

static RCP< const Set >	make_set_union (const set_set &in)

static RCP< const Set >	make_set_intersection (const set_set &in)

RCP< const Set >	set_union (const set_set &in)

RCP< const Set >	set_intersection (const set_set &in)

RCP< const Set >	set_complement_helper (const RCP< const Set > &container, const RCP< const Set > &universe)

RCP< const Set >	set_complement (const RCP< const Set > &universe, const RCP< const Set > &container)

RCP< const Set >	conditionset (const RCP< const Basic > &sym, const RCP< const Boolean > &condition)

bool	is_a_Set (const Basic &b)

RCP< const Complexes >	complexes ()

RCP< const Reals >	reals ()

RCP< const Rationals >	rationals ()

RCP< const Integers >	integers ()

RCP< const Naturals >	naturals ()

RCP< const Naturals0 >	naturals0 ()

RCP< const EmptySet >	emptyset ()

RCP< const UniversalSet >	universalset ()

RCP< const Set >	finiteset (const set_basic &container)

RCP< const Set >	interval (const RCP< const Number > &start, const RCP< const Number > &end, const bool left_open=false, const bool right_open=false)

RCP< const Set >	imageset (const RCP< const Basic > &sym, const RCP< const Basic > &expr, const RCP< const Set > &base)

RCP< const Basic >	simplify (const RCP< const Basic > &x, const Assumptions *assumptions)

RCP< const Set >	solve_poly_linear (const vec_basic &coeffs, const RCP< const Set > &domain)

RCP< const Set >	solve_poly_quadratic (const vec_basic &coeffs, const RCP< const Set > &domain)

RCP< const Set >	solve_poly_cubic (const vec_basic &coeffs, const RCP< const Set > &domain)

RCP< const Set >	solve_poly_quartic (const vec_basic &coeffs, const RCP< const Set > &domain)

RCP< const Set >	solve_poly_heuristics (const vec_basic &coeffs, const RCP< const Set > &domain)

RCP< const Basic >	get_coeff_basic (const integer_class &i)

RCP< const Basic >	get_coeff_basic (const Expression &i)

template<typename Poly >
vec_basic	extract_coeffs (const RCP< const Poly > &f)

RCP< const Set >	solve_poly (const RCP< const Basic > &f, const RCP< const Symbol > &sym, const RCP< const Set > &domain)

RCP< const Set >	solve_rational (const RCP< const Basic > &f, const RCP< const Symbol > &sym, const RCP< const Set > &domain)

bool	is_a_LinearArgTrigEquation (const Basic &b, const Symbol &x)

RCP< const Set >	invertComplex (const RCP< const Basic > &fX, const RCP< const Set > &gY, const RCP< const Symbol > &sym, const RCP< const Dummy > &nD, const RCP< const Set > &domain)

RCP< const Set >	solve_trig (const RCP< const Basic > &f, const RCP< const Symbol > &sym, const RCP< const Set > &domain)

RCP< const Set >	solve (const RCP< const Basic > &f, const RCP< const Symbol > &sym, const RCP< const Set > &domain)

vec_basic	linsolve_helper (const DenseMatrix &A, const DenseMatrix &b)

vec_basic	linsolve (const DenseMatrix &system, const vec_sym &syms)

vec_basic	linsolve (const vec_basic &system, const vec_sym &syms)

set_basic	get_set_from_vec (const vec_sym &syms)

std::pair< DenseMatrix, DenseMatrix >	linear_eqns_to_matrix (const vec_basic &equations, const vec_sym &syms)

void	csr_matmat_pass1 (const CSRMatrix &A, const CSRMatrix &B, CSRMatrix &C)

void	csr_matmat_pass2 (const CSRMatrix &A, const CSRMatrix &B, CSRMatrix &C)

void	csr_diagonal (const CSRMatrix &A, DenseMatrix &D)

void	csr_scale_rows (CSRMatrix &A, const DenseMatrix &X)

void	csr_scale_columns (CSRMatrix &A, const DenseMatrix &X)

void	csr_binop_csr_canonical (const CSRMatrix &A, const CSRMatrix &B, CSRMatrix &C, RCP< const Basic >(&bin_op)(const RCP< const Basic > &, const RCP< const Basic > &))

RCP< const Basic >	xreplace (const RCP< const Basic > &x, const map_basic_basic &subs_dict, bool cache)
	Mappings in the `subs_dict` are applied to the expression tree of `x`

RCP< const Basic >	subs (const RCP< const Basic > &x, const map_basic_basic &subs_dict, bool cache=true)

RCP< const Basic >	msubs (const RCP< const Basic > &x, const map_basic_basic &subs_dict, bool cache)
	Subs which treat f(t) and Derivative(f(t), t) as separate variables.

RCP< const Basic >	ssubs (const RCP< const Basic > &x, const map_basic_basic &subs_dict, bool cache)
	SymPy compatible subs.

RCP< const Symbol >	symbol (const std::string &name)
	inline version to return `Symbol`

RCP< const Dummy >	dummy ()
	inline version to return `Dummy`

RCP< const Dummy >	dummy (const std::string &name)

template<typename To , typename From >
To	implicit_cast (const From &f)

template<typename To , typename From >
To	down_cast (From *f)

template<typename To , typename From >
To	down_cast (From &f)

template<typename To , typename From >
To	numeric_cast (From f, typename std::enable_if<(std::is_signed< From >::value &&std::is_signed< To >::value)\|\|(std::is_unsigned< From >::value &&std::is_unsigned< To >::value)>::type *=nullptr)

template<typename To , typename From >
To	numeric_cast (From f, typename std::enable_if<(std::is_signed< From >::value &&std::is_unsigned< To >::value)>::type *=nullptr)

template<typename To , typename From >
To	numeric_cast (From f, typename std::enable_if<(std::is_unsigned< From >::value &&std::is_signed< To >::value)>::type *=nullptr)

template<typename T , typename... Args>
RCP< T >	make_rcp (Args &&...args)

bool	is_polynomial (const Basic &b, const set_basic &variables={})
	Check if expression is a polynomial.

bool	is_true (tribool x)

bool	is_false (tribool x)

bool	is_indeterminate (tribool x)

tribool	tribool_from_bool (bool x)

tribool	and_tribool (tribool a, tribool b)

tribool	or_tribool (tribool a, tribool b)

tribool	not_tribool (tribool a)

tribool	andwk_tribool (tribool a, tribool b)

tribool	orwk_tribool (tribool a, tribool b)

RCP< const Basic >	tuple (const vec_basic &arg)

void	preorder_traversal (const Basic &b, Visitor &v)

void	postorder_traversal (const Basic &b, Visitor &v)

void	preorder_traversal_stop (const Basic &b, StopVisitor &v)

void	postorder_traversal_stop (const Basic &b, StopVisitor &v)

bool	has_symbol (const Basic &b, const Basic &x)

RCP< const Basic >	coeff (const Basic &b, const Basic &x, const Basic &n)

set_basic	free_symbols (const MatrixBase &m)

set_basic	free_symbols (const Basic &b)

set_basic	function_symbols (const Basic &b)

void	preorder_traversal_local_stop (const Basic &b, LocalStopVisitor &v)

unsigned	count_ops (const vec_basic &a)

template<typename... Args>
set_basic	atoms (const Basic &b)

Variables
RCP< const Integer >	zero = []() { static const RCP<const Integer > c = integer(0) ; return c; }()

RCP< const Integer >	one = []() { static const RCP<const Integer > c = integer(1) ; return c; }()

RCP< const Integer >	minus_one = []() { static const RCP<const Integer > c = integer(-1) ; return c; }()

RCP< const Integer >	two = []() { static const RCP<const Integer > c = integer(2) ; return c; }()

RCP< const Number >	I = []() { static const RCP<const Number > c = Complex::from_two_nums(zero, one) ; return c; }()

RCP< const Constant >	pi = []() { static const RCP<const Constant > c = constant("pi") ; return c; }()

RCP< const Constant >	E = []() { static const RCP<const Constant > c = constant("E") ; return c; }()

RCP< const Constant >	EulerGamma = []() { static const RCP<const Constant > c = constant("EulerGamma") ; return c; }()

RCP< const Constant >	Catalan = []() { static const RCP<const Constant > c = constant("Catalan") ; return c; }()

RCP< const Constant >	GoldenRatio = []() { static const RCP<const Constant > c = constant("GoldenRatio") ; return c; }()

RCP< const Infty >	Inf = []() { static const RCP<const Infty > c = Infty::from_int(1) ; return c; }()

RCP< const Infty >	NegInf = []() { static const RCP<const Infty > c = Infty::from_int(-1) ; return c; }()

RCP< const Infty >	ComplexInf = []() { static const RCP<const Infty > c = Infty::from_int(0) ; return c; }()

RCP< const NaN >	Nan = []() { static const RCP<const NaN > c = make_rcp<NaN>() ; return c; }()

RCP< const Basic >	i2 = []() { static const RCP<const Basic > c = integer(2) ; return c; }()

RCP< const Basic >	i3 = []() { static const RCP<const Basic > c = integer(3) ; return c; }()

RCP< const Basic >	i5 = []() { static const RCP<const Basic > c = integer(5) ; return c; }()

RCP< const Basic >	im2 = []() { static const RCP<const Basic > c = integer(-2) ; return c; }()

RCP< const Basic >	im3 = []() { static const RCP<const Basic > c = integer(-3) ; return c; }()

RCP< const Basic >	im5 = []() { static const RCP<const Basic > c = integer(-5) ; return c; }()

RCP< const Basic >	sq3 = []() { static const RCP<const Basic > c = sqrt_(i3) ; return c; }()

RCP< const Basic >	sq2 = []() { static const RCP<const Basic > c = sqrt_(i2) ; return c; }()

RCP< const Basic >	sq5 = []() { static const RCP<const Basic > c = sqrt_(i5) ; return c; }()

RCP< const Basic >	C0 = []() { static const RCP<const Basic > c = div(sub(sq3, one), mul(i2, sq2)) ; return c; }()

RCP< const Basic >	C1 = []() { static const RCP<const Basic > c = div(one, i2) ; return c; }()

RCP< const Basic >	C2 = []() { static const RCP<const Basic > c = div(sq2, i2) ; return c; }()

RCP< const Basic >	C3 = []() { static const RCP<const Basic > c = div(sq3, i2) ; return c; }()

RCP< const Basic >	C4 = []() { static const RCP<const Basic > c = div(add(sq3, one), mul(i2, sq2)) ; return c; }()

RCP< const Basic >	C5 = []() { static const RCP<const Basic > c = div(sqrt_(sub(i5, sqrt_(i5))), integer(8)) ; return c; }()

RCP< const Basic >	C6 = []() { static const RCP<const Basic > c = div(sub(sqrt_(i5), one), integer(4)) ; return c; }()

RCP< const Basic >	mC0 = []() { static const RCP<const Basic > c = mul(minus_one, C0) ; return c; }()

RCP< const Basic >	mC1 = []() { static const RCP<const Basic > c = mul(minus_one, C1) ; return c; }()

RCP< const Basic >	mC2 = []() { static const RCP<const Basic > c = mul(minus_one, C2) ; return c; }()

RCP< const Basic >	mC3 = []() { static const RCP<const Basic > c = mul(minus_one, C3) ; return c; }()

RCP< const Basic >	mC4 = []() { static const RCP<const Basic > c = mul(minus_one, C4) ; return c; }()

RCP< const Basic >	mC5 = []() { static const RCP<const Basic > c = mul(minus_one, C5) ; return c; }()

RCP< const Basic >	mC6 = []() { static const RCP<const Basic > c = mul(minus_one, C6) ; return c; }()

RCP< const BooleanAtom >	boolTrue = []() { static const RCP<const BooleanAtom> c = make_rcp<BooleanAtom>( true ); return c; }()

RCP< const BooleanAtom >	boolFalse = []() { static const RCP<const BooleanAtom> c = make_rcp<BooleanAtom>( false ); return c; }()

Detailed Description

Main namespace for SymEngine package.

Typedef Documentation

◆ enable_if_t

template<bool B, class T = void>

using SymEngine::enable_if_t = typedef typename std::enable_if<B, T>::type

Definition at line 103 of file dict.h.

◆ fn

typedef std::function<double(const Basic &)> SymEngine::fn

Definition at line 451 of file eval_double.cpp.

◆ hash_t

typedef uint64_t SymEngine::hash_t

Definition at line 32 of file dict.h.

◆ integer_class

typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<>, boost::multiprecision::et_off> SymEngine::integer_class

Definition at line 54 of file mp_class.h.

◆ map_basic_basic

typedef std::map<RCP<const Basic>, RCP<const Basic>, RCPBasicKeyLess> SymEngine::map_basic_basic

Definition at line 57 of file dict.h.

◆ map_basic_num

typedef std::map<RCP<const Basic>, RCP<const Number>, RCPBasicKeyLess> SymEngine::map_basic_num

Definition at line 55 of file dict.h.

◆ map_int_Expr

typedef std::map<int, Expression> SymEngine::map_int_Expr

Definition at line 62 of file dict.h.

◆ map_integer_uint

typedef std::map<RCP<const Integer>, unsigned, RCPIntegerKeyLess> SymEngine::map_integer_uint

Definition at line 59 of file dict.h.

◆ map_uint_mpq

typedef std::map<unsigned, rational_class> SymEngine::map_uint_mpq

Definition at line 61 of file dict.h.

◆ map_uint_mpz

typedef std::map<unsigned, integer_class> SymEngine::map_uint_mpz

Definition at line 60 of file dict.h.

◆ map_vec_mpz

typedef std::map<vec_uint, integer_class> SymEngine::map_vec_mpz

Definition at line 53 of file dict.h.

◆ map_vec_uint

typedef std::map<vec_uint, unsigned long long int> SymEngine::map_vec_uint

Definition at line 52 of file dict.h.

◆ multiset_basic

typedef std::multiset<RCP<const Basic>, RCPBasicKeyLess> SymEngine::multiset_basic

Definition at line 51 of file dict.h.

◆ permutelist

typedef std::vector<std::pair<int, int> > SymEngine::permutelist

Definition at line 99 of file matrix.h.

◆ PiecewiseVec

typedef std::vector<std::pair<RCP<const Basic>, RCP<const Boolean> > > SymEngine::PiecewiseVec

Definition at line 78 of file logic.h.

◆ rational_class

typedef boost::multiprecision::number< boost::multiprecision::cpp_rational_backend, boost::multiprecision::et_off> SymEngine::rational_class

Definition at line 57 of file mp_class.h.

◆ set_basic

typedef std::set<RCP<const Basic>, RCPBasicKeyLess> SymEngine::set_basic

Definition at line 50 of file dict.h.

◆ set_boolean

typedef std::set<RCP<const Boolean>, RCPBasicKeyLess> SymEngine::set_boolean

Definition at line 14 of file logic.h.

◆ set_set

typedef std::set<RCP<const Set>, RCPBasicKeyLess> SymEngine::set_set

Definition at line 24 of file sets.h.

◆ TwoArgFunction

typedef TwoArgBasic<Function> SymEngine::TwoArgFunction

Definition at line 141 of file functions.h.

◆ umap_basic_basic

typedef std::unordered_map<RCP<const Basic>, RCP<const Basic>, RCPBasicHash, RCPBasicKeyEq> SymEngine::umap_basic_basic

Definition at line 40 of file dict.h.

◆ umap_basic_bool

typedef std::unordered_map<RCP<const Basic>, bool, RCPBasicHash, RCPBasicKeyEq> SymEngine::umap_basic_bool

Definition at line 11 of file assumptions.h.

◆ umap_basic_num

typedef std::unordered_map<RCP<const Basic>, RCP<const Number>, RCPBasicHash, RCPBasicKeyEq> SymEngine::umap_basic_num

Definition at line 35 of file dict.h.

◆ umap_basic_uint

typedef std::unordered_map<RCP<const Basic>, unsigned int, RCPBasicHash, RCPBasicKeyEq> SymEngine::umap_basic_uint

Definition at line 65 of file dict.h.

◆ umap_int_basic

typedef std::unordered_map<int, RCP<const Basic> > SymEngine::umap_int_basic

Definition at line 37 of file dict.h.

◆ umap_short_basic

typedef std::unordered_map<short, RCP<const Basic> > SymEngine::umap_short_basic

Definition at line 36 of file dict.h.

◆ umap_uvec_mpz

typedef std::unordered_map<vec_uint, integer_class, vec_hash<vec_uint> > SymEngine::umap_uvec_mpz

Definition at line 74 of file dict.h.

◆ umap_vec_expr

typedef std::unordered_map<vec_int, Expression, vec_hash<vec_int> > SymEngine::umap_vec_expr

Definition at line 78 of file dict.h.

◆ umap_vec_mpz

typedef std::unordered_map<vec_int, integer_class, vec_hash<vec_int> > SymEngine::umap_vec_mpz

Definition at line 76 of file dict.h.

◆ uset_basic

typedef std::unordered_set<RCP<const Basic>, RCPBasicHash, RCPBasicKeyEq> SymEngine::uset_basic

Definition at line 42 of file dict.h.

◆ vec_basic

typedef std::vector<RCP<const Basic> > SymEngine::vec_basic

Definition at line 45 of file dict.h.

◆ vec_boolean

typedef std::vector<RCP<const Boolean> > SymEngine::vec_boolean

Definition at line 15 of file logic.h.

◆ vec_int

typedef std::vector<int> SymEngine::vec_int

Definition at line 44 of file dict.h.

◆ vec_integer

typedef std::vector<RCP<const Integer> > SymEngine::vec_integer

Definition at line 46 of file dict.h.

◆ vec_integer_class

typedef std::vector<integer_class> SymEngine::vec_integer_class

Definition at line 48 of file dict.h.

◆ vec_pair

typedef std::vector<std::pair<RCP<const Basic>, RCP<const Basic> > > SymEngine::vec_pair

Definition at line 66 of file dict.h.

◆ vec_sym

typedef std::vector<RCP<const Symbol> > SymEngine::vec_sym

Definition at line 49 of file dict.h.

◆ vec_uint

typedef std::vector<unsigned int> SymEngine::vec_uint

Definition at line 47 of file dict.h.

Enumeration Type Documentation

◆ EvalfDomain

enum class SymEngine::EvalfDomain

strong

Definition at line 28 of file eval.h.

                       {
    Complex = 0,
    Real = 1,
    Symbolic = 2,
};

◆ PrecedenceEnum

enum class SymEngine::PrecedenceEnum

strong

Definition at line 13 of file strprinter.h.

13{ Relational, Add, Mul, Pow, Atom };

SymEngine::Add

The base class for representing addition in symbolic expressions.

Definition add.h:27

SymEngine::Mul

Definition mul.h:74

SymEngine::Pow

Definition pow.h:18

SymEngine::Relational

Definition logic.h:179

◆ tribool

enum class SymEngine::tribool

strong

Definition at line 7 of file tribool.h.

7{ indeterminate = -1, trifalse = 0, tritrue = 1 };

◆ TypeID

enum SymEngine::TypeID

Enumerator
TypeID_Count	The 'TypeID_Count' returns the number of elements in 'TypeID'. For this to work, do not assign numbers to the elements above (or if you do, you must assign the correct count below).

Definition at line 43 of file basic.h.

            {
#define SYMENGINE_INCLUDE_ALL
#define SYMENGINE_ENUM(type, Class) type,
#include "symengine/type_codes.inc"
#undef SYMENGINE_ENUM
#undef SYMENGINE_INCLUDE_ALL
    TypeID_Count
};

Function Documentation

◆ _basic_to_mpoly() [1/2]

template<typename P >

enable_if_t< std::is_same< MIntPoly, P >::value, typename P::container_type > SymEngine::_basic_to_mpoly	(	const RCP< const Basic > &	basic,
		const set_basic &	gens
	)

Definition at line 527 of file basic_conversions.h.

{
    BasicToMIntPoly v(gens);
    return v.apply(*basic);
}

◆ _basic_to_mpoly() [2/2]

template<typename P >

enable_if_t< std::is_same< MExprPoly, P >::value, typename P::container_type > SymEngine::_basic_to_mpoly	(	const RCP< const Basic > &	basic,
		const set_basic &	gens
	)

Definition at line 535 of file basic_conversions.h.

{
    BasicToMExprPoly v(gens);
    return v.apply(*basic);
}

◆ _basic_to_upoly() [1/3]

template<typename T , typename P >

enable_if_t< std::is_same< T, UExprDict >::value, T > SymEngine::_basic_to_upoly	(	const RCP< const Basic > &	basic,
		const RCP< const Basic > &	gen
	)

Definition at line 270 of file basic_conversions.h.

{
    BasicToUExprPoly v(gen);
    return v.apply(*basic);
}

◆ _basic_to_upoly() [2/3]

template<typename T , typename P >

enable_if_t< std::is_base_of< UIntPolyBase< T, P >, P >::value, T > SymEngine::_basic_to_upoly	(	const RCP< const Basic > &	basic,
		const RCP< const Basic > &	gen
	)

Definition at line 278 of file basic_conversions.h.

{
    BasicToUIntPoly<P> v(gen);
    return v.apply(*basic);
}

◆ _basic_to_upoly() [3/3]

template<typename T , typename P >

enable_if_t< std::is_base_of< URatPolyBase< T, P >, P >::value, T > SymEngine::_basic_to_upoly	(	const RCP< const Basic > &	basic,
		const RCP< const Basic > &	gen
	)

Definition at line 286 of file basic_conversions.h.

{
    BasicToURatPoly<P> v(gen);
    return v.apply(*basic);
}

◆ _find_gens_poly()

umap_basic_num SymEngine::_find_gens_poly ( const RCP< const Basic > & x )

Definition at line 165 of file basic_conversions.cpp.

{
    PolyGeneratorVisitor v;
    return v.apply(*x);
}

◆ _find_gens_poly_pow()

umap_basic_num SymEngine::_find_gens_poly_pow	(	const RCP< const Basic > &	x,
		const RCP< const Basic > &	base
	)

Definition at line 171 of file basic_conversions.cpp.

{
    PolyGeneratorVisitorPow v;
    return v.apply(*x, base);
}

◆ _imulnum()

void SymEngine::_imulnum	(	const Ptr< RCP< const Number > > &	self,
		const RCP< const Number > &	other
	)

inline

Definition at line 16 of file expand.cpp.

{
    *self = _mulnum(*self, other);
}

◆ _is_nthroot_mod_prime_power()

bool SymEngine::_is_nthroot_mod_prime_power	(	const integer_class &	a,
		const integer_class &	n,
		const integer_class &	p,
		const unsigned	k
	)

Definition at line 1308 of file ntheory.cpp.

{
    integer_class pk;
    if (a % p != 0) {
        if (p == 2) {
            integer_class t;
            unsigned c = numeric_cast<unsigned>(mp_scan1(n));
 
            // Handle special cases of k = 1 and k = 2.
            if (k == 1) {
                return true;
            }
            if (k == 2) {
                if (c > 0 and a % 4 == 3) {
                    return false;
                }
                return true;
            }
            if (c >= k - 2) {
                c = k - 2; // Since x**(2**c) == x**(2**(k - 2)) mod 2**k, let c
                           // = k - 2.
            }
            if (c == 0) {
                // x**r == a mod 2**k and x**2**(k - 2) == 1 mod 2**k, implies
                // x**(r * s) == x == a**s mod 2**k.
                return true;
            }
 
            // First, solve for y**2**c == a mod 2**k where y == x**r
            t = integer_class(1) << (c + 2);
            mp_fdiv_r(t, a, t);
            // Check for a == y**2**c == 1 mod 2**(c + 2).
            if (t != 1)
                return false;
            return true;
        } else {
            return _is_nthroot_mod1(a, n, p, k);
        }
    } else {
        integer_class _a;
        mp_pow_ui(pk, p, k);
        _a = a % pk;
        integer_class pm;
        if (_a == 0) {
            return true;
        } else {
            unsigned r = 1;
            mp_divexact(_a, _a, p);
            while (_a % p == 0) {
                mp_divexact(_a, _a, p);
                ++r;
            }
            if (r < n or r % n != 0
                or not _is_nthroot_mod_prime_power(_a, n, p, k - r)) {
                return false;
            }
            return true;
        }
    }
    return true;
}

◆ _mulnum()

RCP< const Number > SymEngine::_mulnum	(	const RCP< const Number > &	x,
		const RCP< const Number > &	y
	)

inline

Definition at line 6 of file expand.cpp.

{
    if (eq(*x, *one))
        return y;
    if (eq(*y, *one))
        return x;
    return x->mul(*y);
}

◆ _print_sign()

template<typename T >

char SymEngine::_print_sign ( const T & i )

Definition at line 659 of file strprinter.cpp.

{
    if (i < 0) {
        return '-';
    } else {
        return '+';
    }
}

◆ _str()

static std::string SymEngine::_str ( const Basic & a )

static

Definition at line 88 of file cwrapper.cpp.

{
    return a.__str__();
}

◆ abs()

RCP< const Basic > SymEngine::abs ( const RCP< const Basic > & arg )

Canonicalize Abs:

Definition at line 3492 of file functions.cpp.

{
    if (is_a<Integer>(*arg)) {
        RCP<const Integer> arg_ = rcp_static_cast<const Integer>(arg);
        if (arg_->is_negative()) {
            return arg_->neg();
        } else {
            return arg_;
        }
    } else if (is_a<Rational>(*arg)) {
        RCP<const Rational> arg_ = rcp_static_cast<const Rational>(arg);
        if (arg_->is_negative()) {
            return arg_->neg();
        } else {
            return arg_;
        }
    } else if (is_a<Complex>(*arg)) {
        RCP<const Complex> arg_ = rcp_static_cast<const Complex>(arg);
        return sqrt(Rational::from_mpq(arg_->real_ * arg_->real_
                                       + arg_->imaginary_ * arg_->imaginary_));
    } else if (is_a_Number(*arg)
               and not down_cast<const Number &>(*arg).is_exact()) {
        return down_cast<const Number &>(*arg).get_eval().abs(*arg);
    }
    if (is_a<Abs>(*arg)) {
        return arg;
    }
 
    RCP<const Basic> d;
    handle_minus(arg, outArg(d));
    return make_rcp<const Abs>(d);
}

◆ acos()

RCP< const Basic > SymEngine::acos ( const RCP< const Basic > & arg )

Canonicalize ACos:

Definition at line 1402 of file functions.cpp.

{
    if (eq(*arg, *zero))
        return div(pi, i2);
    else if (eq(*arg, *one))
        return zero;
    else if (eq(*arg, *minus_one))
        return pi;
    else if (is_a_Number(*arg)
             and not down_cast<const Number &>(*arg).is_exact()) {
        return down_cast<const Number &>(*arg).get_eval().acos(*arg);
    }
 
    RCP<const Basic> index;
    bool b = inverse_lookup(inverse_cst(), arg, outArg(index));
    if (b) {
        return sub(div(pi, i2), div(pi, index));
    } else {
        return make_rcp<const ACos>(arg);
    }
}

◆ acosh()

RCP< const Basic > SymEngine::acosh ( const RCP< const Basic > & arg )

Canonicalize ACosh:

Definition at line 2461 of file functions.cpp.

{
    // TODO: Lookup into a cst table once complex is implemented
    if (eq(*arg, *one))
        return zero;
    if (is_a_Number(*arg) and not down_cast<const Number &>(*arg).is_exact()) {
        return down_cast<const Number &>(*arg).get_eval().acosh(*arg);
    }
    return make_rcp<const ACosh>(arg);
}

◆ acot()

RCP< const Basic > SymEngine::acot ( const RCP< const Basic > & arg )

Canonicalize ACot:

Definition at line 1566 of file functions.cpp.

{
    if (eq(*arg, *zero))
        return div(pi, i2);
    else if (eq(*arg, *one))
        return div(pi, mul(i2, i2));
    else if (eq(*arg, *minus_one))
        return mul(i3, div(pi, mul(i2, i2)));
    else if (is_a_Number(*arg)
             and not down_cast<const Number &>(*arg).is_exact()) {
        return down_cast<const Number &>(*arg).get_eval().acot(*arg);
    }
 
    RCP<const Basic> index;
    bool b = inverse_lookup(inverse_tct(), arg, outArg(index));
    if (b) {
        return sub(div(pi, i2), div(pi, index));
    } else {
        return make_rcp<const ACot>(arg);
    }
}

◆ acoth()

RCP< const Basic > SymEngine::acoth ( const RCP< const Basic > & arg )

Canonicalize ACoth:

Definition at line 2534 of file functions.cpp.

{
    if (is_a_Number(*arg)) {
        RCP<const Number> _arg = rcp_static_cast<const Number>(arg);
        if (not _arg->is_exact()) {
            return _arg->get_eval().acoth(*_arg);
        } else if (_arg->is_negative()) {
            return neg(acoth(zero->sub(*_arg)));
        }
    }
    RCP<const Basic> d;
    bool b = handle_minus(arg, outArg(d));
    if (b) {
        return neg(acoth(d));
    }
    return make_rcp<const ACoth>(d);
}

◆ acsc()

RCP< const Basic > SymEngine::acsc ( const RCP< const Basic > & arg )

Canonicalize ACsc:

Definition at line 1484 of file functions.cpp.

{
    if (eq(*arg, *one))
        return div(pi, i2);
    else if (eq(*arg, *minus_one))
        return div(pi, im2);
    else if (is_a_Number(*arg)
             and not down_cast<const Number &>(*arg).is_exact()) {
        return down_cast<const Number &>(*arg).get_eval().acsc(*arg);
    }
 
    RCP<const Basic> index;
    bool b = inverse_lookup(inverse_cst(), div(one, arg), outArg(index));
    if (b) {
        return div(pi, index);
    } else {
        return make_rcp<const ACsc>(arg);
    }
}

◆ acsch()

RCP< const Basic > SymEngine::acsch ( const RCP< const Basic > & arg )

Canonicalize ACsch:

Definition at line 2422 of file functions.cpp.

{
    if (eq(*arg, *one))
        return log(add(one, sq2));
    if (eq(*arg, *minus_one))
        return log(sub(sq2, one));
 
    if (is_a_Number(*arg)) {
        RCP<const Number> _arg = rcp_static_cast<const Number>(arg);
        if (not _arg->is_exact()) {
            return _arg->get_eval().acsch(*_arg);
        }
    }
 
    RCP<const Basic> d;
    bool b = handle_minus(arg, outArg(d));
    if (b) {
        return neg(acsch(d));
    }
    return make_rcp<const ACsch>(d);
}

◆ add() [1/2]

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

Adds two objects (safely).

This implementation is slower than the methods of Add, however it is conceptually simpler and also safer, as it is more general and can perform canonicalization.

Note that:

‍x + y will return an Add. x + x will return Mul (2*x).

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 )

Sums the elements of a vector.

This should be faster for n elements compared to performing n-1 additions.

Data Structures

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ enable_if_t

◆ fn

◆ hash_t

◆ integer_class

◆ map_basic_basic

◆ map_basic_num

◆ map_int_Expr

◆ map_integer_uint

◆ map_uint_mpq

◆ map_uint_mpz

◆ map_vec_mpz

◆ map_vec_uint

◆ multiset_basic

◆ permutelist

◆ PiecewiseVec

◆ rational_class

◆ set_basic

◆ set_boolean

◆ set_set

◆ TwoArgFunction

◆ umap_basic_basic

◆ umap_basic_bool

◆ umap_basic_num

◆ umap_basic_uint

◆ umap_int_basic

◆ umap_short_basic

◆ umap_uvec_mpz

◆ umap_vec_expr

◆ umap_vec_mpz

◆ uset_basic

◆ vec_basic

◆ vec_boolean

◆ vec_int

◆ vec_integer

◆ vec_integer_class

◆ vec_pair

◆ vec_sym

◆ vec_uint

Enumeration Type Documentation

◆ EvalfDomain

◆ PrecedenceEnum

◆ tribool

◆ TypeID

Function Documentation

◆ _basic_to_mpoly() [1/2]

◆ _basic_to_mpoly() [2/2]

◆ _basic_to_upoly() [1/3]

◆ _basic_to_upoly() [2/3]

◆ _basic_to_upoly() [3/3]

◆ _find_gens_poly()

◆ _find_gens_poly_pow()

◆ _imulnum()

◆ _is_nthroot_mod_prime_power()

◆ _mulnum()

◆ _print_sign()

◆ _str()

◆ abs()

◆ acos()

◆ acosh()

◆ acot()

◆ acoth()

◆ acsc()

◆ acsch()

◆ add() [1/2]

◆ add() [2/2]