SymEngine Namespace Reference

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). More...
RCP< const Basic >	add (const vec_basic &a)
	Sums the elements of a vector. More...
RCP< const Basic >	sub (const RCP< const Basic > &a, const RCP< const Basic > &b)
	Substracts b from a. More...
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 More...
bool	neq (const Basic &a, const Basic &b)
	Checks inequality for a and b More...
template<class T >
bool	is_a (const Basic &b)
	Templatised version to check is_a type. More...
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. More...
std::ostream &	operator<< (std::ostream &out, const SymEngine::Basic &p)
	<< Operator More...
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. More...
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 More...
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. More...
RCP< const Basic >	expand (const RCP< const Basic > &self, bool deep=true)
	Expands self More...
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 Constant >	constant (const std::string &name)
	inline version to return Constant More...
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. More...
RCP< const Basic >	sdiff (const RCP< const Basic > &arg, const RCP< const Basic > &x, bool cache)
	SymPy style differentiation for non-symbol variables. More...
std::ostream &	operator<< (std::ostream &out, const SymEngine::umap_basic_num &d)
	print functions More...
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 More...
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. More...
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. More...
RCP< const Basic >	floor (const RCP< const Basic > &arg)
	Canonicalize Floor: More...
RCP< const Basic >	ceiling (const RCP< const Basic > &arg)
	Canonicalize Ceiling: More...
RCP< const Basic >	truncate (const RCP< const Basic > &arg)
	Canonicalize Truncate: More...
RCP< const Basic >	sin (const RCP< const Basic > &arg)
	Canonicalize Sin: More...
RCP< const Basic >	cos (const RCP< const Basic > &arg)
	Canonicalize Cos: More...
RCP< const Basic >	tan (const RCP< const Basic > &arg)
	Canonicalize Tan: More...
RCP< const Basic >	cot (const RCP< const Basic > &arg)
	Canonicalize Cot: More...
RCP< const Basic >	csc (const RCP< const Basic > &arg)
	Canonicalize Csc: More...
RCP< const Basic >	sec (const RCP< const Basic > &arg)
	Canonicalize Sec: More...
RCP< const Basic >	trig_to_sqrt (const RCP< const Basic > &arg)
RCP< const Basic >	asin (const RCP< const Basic > &arg)
	Canonicalize ASin: More...
RCP< const Basic >	acos (const RCP< const Basic > &arg)
	Canonicalize ACos: More...
RCP< const Basic >	asec (const RCP< const Basic > &arg)
	Canonicalize ASec: More...
RCP< const Basic >	acsc (const RCP< const Basic > &arg)
	Canonicalize ACsc: More...
RCP< const Basic >	atan (const RCP< const Basic > &arg)
	Canonicalize ATan: More...
RCP< const Basic >	acot (const RCP< const Basic > &arg)
	Canonicalize ACot: More...
RCP< const Basic >	atan2 (const RCP< const Basic > &num, const RCP< const Basic > &den)
	Canonicalize ATan2: More...
RCP< const Basic >	log (const RCP< const Basic > &arg)
	Returns the Natural Logarithm from argument arg More...
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: More...
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: More...
RCP< const Basic >	sinh (const RCP< const Basic > &arg)
	Canonicalize Sinh: More...
RCP< const Basic >	csch (const RCP< const Basic > &arg)
	Canonicalize Csch: More...
RCP< const Basic >	cosh (const RCP< const Basic > &arg)
	Canonicalize Cosh: More...
RCP< const Basic >	sech (const RCP< const Basic > &arg)
	Canonicalize Sech: More...
RCP< const Basic >	tanh (const RCP< const Basic > &arg)
	Canonicalize Tanh: More...
RCP< const Basic >	coth (const RCP< const Basic > &arg)
	Canonicalize Coth: More...
RCP< const Basic >	asinh (const RCP< const Basic > &arg)
	Canonicalize ASinh: More...
RCP< const Basic >	acsch (const RCP< const Basic > &arg)
	Canonicalize ACsch: More...
RCP< const Basic >	acosh (const RCP< const Basic > &arg)
	Canonicalize ACosh: More...
RCP< const Basic >	atanh (const RCP< const Basic > &arg)
	Canonicalize ATanh: More...
RCP< const Basic >	acoth (const RCP< const Basic > &arg)
	Canonicalize ACoth: More...
RCP< const Basic >	asech (const RCP< const Basic > &arg)
	Canonicalize ASech: More...
RCP< const Basic >	kronecker_delta (const RCP< const Basic > &i, const RCP< const Basic > &j)
	Canonicalize KroneckerDelta: More...
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: More...
RCP< const Basic >	zeta (const RCP< const Basic > &s, const RCP< const Basic > &a)
	Create a new Zeta instance: More...
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: More...
RCP< const Basic >	erf (const RCP< const Basic > &arg)
	Canonicalize Erf: More...
RCP< const Basic >	erfc (const RCP< const Basic > &arg)
	Canonicalize Erfc: More...
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: More...
RCP< const Basic >	lowergamma (const RCP< const Basic > &s, const RCP< const Basic > &x)
	Canonicalize LowerGamma: More...
RCP< const Basic >	uppergamma (const RCP< const Basic > &s, const RCP< const Basic > &x)
	Canonicalize UpperGamma: More...
RCP< const Basic >	loggamma (const RCP< const Basic > &arg)
	Canonicalize LogGamma: More...
RCP< const Basic >	beta (const RCP< const Basic > &x, const RCP< const Basic > &y)
	Canonicalize Beta: More...
RCP< const Basic >	polygamma (const RCP< const Basic > &n, const RCP< const Basic > &x)
	Canonicalize PolyGamma. More...
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: More...
RCP< const Basic >	max (const vec_basic &arg)
	Canonicalize Max: More...
RCP< const Basic >	min (const vec_basic &arg)
	Canonicalize Min: More...
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. More...
RCP< const Integer >	iabs (const Integer &n)
	Integer Absolute value. More...
int	i_nth_root (const Ptr< RCP< const Integer > > &r, const Integer &a, unsigned long int n)
	Integer nth root. More...
bool	perfect_square (const Integer &n)
	Perfect Square. More...
bool	perfect_power (const Integer &n)
	Perfect Square. More...
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. More...
RCP< const Boolean >	Eq (const RCP< const Basic > &lhs, const RCP< const Basic > &rhs)
	Returns the canonicalized Equality object from the two arguments. More...
RCP< const Boolean >	Ne (const RCP< const Basic > &lhs, const RCP< const Basic > &rhs)
	Returns the canonicalized Unequality object from the arguments. More...
RCP< const Boolean >	Le (const RCP< const Basic > &lhs, const RCP< const Basic > &rhs)
	Returns the canonicalized LessThan object from the arguments. More...
RCP< const Boolean >	Ge (const RCP< const Basic > &lhs, const RCP< const Basic > &rhs)
	Convenience function returning LessThan object. More...
RCP< const Boolean >	Lt (const RCP< const Basic > &lhs, const RCP< const Basic > &rhs)
	Returns the canonicalized StrictLessThan object from the arguments. More...
RCP< const Boolean >	Gt (const RCP< const Basic > &lhs, const RCP< const Basic > &rhs)
	Convenience function returning StrictLessThan object. More...
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. More...
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. More...
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. More...
RCP< const Basic >	mul (const vec_basic &a)
RCP< const Basic >	div (const RCP< const Basic > &a, const RCP< const Basic > &b)
	Division. More...
RCP< const Basic >	neg (const RCP< const Basic > &a)
	Negation. More...
RCP< const Integer >	gcd (const Integer &a, const Integer &b)
	Greatest Common Divisor. More...
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. More...
RCP< const Integer >	lcm (const Integer &a, const Integer &b)
	Least Common Multiple. More...
int	mod_inverse (const Ptr< RCP< const Integer > > &b, const Integer &a, const Integer &m)
	inverse modulo More...
RCP< const Integer >	mod (const Integer &n, const Integer &d)
	modulo round toward zero More...
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 More...
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. More...
void	fibonacci2 (const Ptr< RCP< const Integer > > &g, const Ptr< RCP< const Integer > > &s, unsigned long n)
	Fibonacci n and n-1. More...
RCP< const Integer >	lucas (unsigned long n)
	Lucas number. More...
void	lucas2 (const Ptr< RCP< const Integer > > &g, const Ptr< RCP< const Integer > > &s, unsigned long n)
	Lucas number n and n-1. More...
RCP< const Integer >	binomial (const Integer &n, unsigned long k)
	Binomial Coefficient. More...
RCP< const Integer >	factorial (unsigned long n)
	Factorial. More...
bool	divides (const Integer &a, const Integer &b)
int	probab_prime_p (const Integer &a, unsigned reps=25)
	Probabilistic Prime. More...
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. More...
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. More...
int	factor_pollard_rho_method (const Ptr< RCP< const Integer > > &f, const Integer &n, unsigned retries=5)
	Factor using Pollard's rho methods. More...
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 More...
void	prime_factor_multiplicities (map_integer_uint &primes, const Integer &n)
	Find multiplicities of prime factors of n More...
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. More...
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. More...
bool	primitive_root (const Ptr< RCP< const Integer > > &g, const Integer &n)
	Computes a primitive root. Returns false if no primitive root exists. More...
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. More...
RCP< const Integer >	carmichael (const RCP< const Integer > &n)
	Carmichael function. More...
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. More...
int	legendre (const Integer &a, const Integer &n)
	Legendre Function. More...
int	jacobi (const Integer &a, const Integer &n)
	Jacobi Function. More...
int	kronecker (const Integer &a, const Integer &n)
	Kronecker Function. More...
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. More...
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. More...
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. More...
bool	is_quad_residue (const Integer &a, const Integer &p)
	Returns true if 'a' is a quadratic residue of 'p'. More...
bool	is_nth_residue (const Integer &a, const Integer &n, const Integer &mod)
	Returns true if 'a' is a nth power residue of 'mod'. More...
int	mobius (const Integer &a)
	Mobius Function. More...
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. More...
integer_class	mp_principal_polygonal_root (const integer_class &s, const integer_class &x)
	Numeric calculation of the principal s-gonal root of x. More...
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. More...
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. More...
RCP< const Basic >	principal_polygonal_root (const RCP< const Basic > &s, const RCP< const Basic > &x)
	The principal s-gonal root of x. More...
RCP< const Number >	addnum (const RCP< const Number > &self, const RCP< const Number > &other)
	Add self and other More...
RCP< const Number >	subnum (const RCP< const Number > &self, const RCP< const Number > &other)
	Subtract self and other More...
RCP< const Number >	mulnum (const RCP< const Number > &self, const RCP< const Number > &other)
	Multiply self and other More...
RCP< const Number >	divnum (const RCP< const Number > &self, const RCP< const Number > &other)
	Divide self and other More...
RCP< const Number >	pownum (const RCP< const Number > &self, const RCP< const Number > &other)
	Raise self to power other More...
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. More...
tribool	is_nonzero (const Basic &b, const Assumptions *assumptions=nullptr)
	Check if a number is non-zero. More...
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) More...
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> More...
RCP< const Number >	rational (long n, long d)
	convenience creator from two longs More...
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 More...
void	poly_mul (const umap_vec_mpz &A, const umap_vec_mpz &B, umap_vec_mpz &C)
	Multiply two polynomials: C = A*B More...
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. More...
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. More...
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 More...
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. More...
RCP< const Basic >	ssubs (const RCP< const Basic > &x, const map_basic_basic &subs_dict, bool cache)
	SymPy compatible subs. More...
RCP< const Symbol >	symbol (const std::string &name)
	inline version to return Symbol More...
RCP< const Dummy >	dummy ()
	inline version to return Dummy More...
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. More...
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.

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

tribool

enum class SymEngine::tribool

strong

Definition at line 7 of file tribool.h.

{ 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 87 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.

Parameters

a	is a vector.

Returns

sum of elements of the input vector a.

Definition at line 481 of file add.cpp.

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

add_dense_dense()

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

Definition at line 651 of file dense_matrix.cpp.

{
    SYMENGINE_ASSERT(A.row_ == B.row_ and A.col_ == B.col_ and A.row_ == C.row_
                     and A.col_ == C.col_);
 
    unsigned row = A.row_, col = A.col_;
 
    for (unsigned i = 0; i < row; i++) {
        for (unsigned j = 0; j < col; j++) {
            C.m_[i * col + j] = add(A.m_[i * col + j], B.m_[i * col + j]);
        }
    }
}

add_dense_scalar()

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

Definition at line 665 of file dense_matrix.cpp.

{
    SYMENGINE_ASSERT(A.row_ == B.row_ and A.col_ == B.col_);
 
    unsigned row = A.row_, col = A.col_;
 
    for (unsigned i = 0; i < row; i++) {
        for (unsigned j = 0; j < col; j++) {
            B.m_[i * col + j] = add(A.m_[i * col + j], k);
        }
    }
}

add_mpoly()

template<typename Poly >

RCP< const Poly > SymEngine::add_mpoly	(	const Poly &	a,
		const Poly &	b
	)

Definition at line 492 of file msymenginepoly.h.

{
    typename Poly::container_type x, y;
    set_basic s = get_translated_container(x, y, a, b);
    x += y;
    return Poly::from_container(s, std::move(x));
}

add_to_sorted_vec()

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

Definition at line 194 of file cse.cpp.

{
    if (std::find(vec.begin(), vec.end(), number) == vec.end()) {
        // Add number if not found
        vec.insert(std::upper_bound(vec.begin(), vec.end(), number), number);
    }
}

add_upoly()

template<typename Poly >

RCP< const Poly > SymEngine::add_upoly	(	const Poly &	a,
		const Poly &	b
	)

Definition at line 672 of file upolybase.h.

{
    if (!(a.get_var()->__eq__(*b.get_var())))
        throw SymEngineException("Error: variables must agree.");
 
    auto dict = a.get_poly();
    dict += b.get_poly();
    return Poly::from_container(a.get_var(), std::move(dict));
}

addnum()

RCP< const Number > SymEngine::addnum ( const RCP< const Number > &  self, const RCP< const Number > &  other  )

inline

Add self and other

Definition at line 81 of file number.h.

{
    return self->add(*other);
}

and_or()

template<typename caller >

RCP< const Boolean > SymEngine::and_or	(	const set_boolean &	s,
		const bool &	op_x_notx
	)

Definition at line 465 of file logic.cpp.

{
    set_boolean args;
    for (auto &a : s) {
        if (is_a<BooleanAtom>(*a)) {
            auto val = down_cast<const BooleanAtom &>(*a).get_val();
            if (val == op_x_notx)
                return boolean(op_x_notx);
            else
                continue;
        }
        if (is_a<caller>(*a)) {
            const caller &to_insert = down_cast<const caller &>(*a);
            auto container = to_insert.get_container();
            args.insert(container.begin(), container.end());
            continue;
        }
        args.insert(a);
    }
    for (auto &a : args) {
        if (args.find(logical_not(a)) != args.end())
            return boolean(op_x_notx);
    }
    if (not op_x_notx) {
        for (auto it = args.begin(); it != args.end(); it++) {
            if (is_a<Contains>(**it)
                and is_a<Symbol>(*down_cast<const Contains &>(**it).get_expr())
                and is_a<FiniteSet>(
                    *down_cast<const Contains &>(**it).get_set())) {
                auto sym = down_cast<const Contains &>(**it).get_expr();
                // iterate through args and check for the condition that
                // defines the domain of sym.
                // Simplify if that set is a FiniteSet.
                set_basic present;
                auto fset = down_cast<const FiniteSet &>(
                                *down_cast<const Contains &>(**it).get_set())
                                .get_container();
                // If there exists atleast one number/constant, then only we can
                // simplify.
                bool check = false;
                for (const auto &elem : fset) {
                    if (is_a_Number(*elem) or is_a<Constant>(*elem)) {
                        check = true;
                        break;
                    }
                }
                if (!check)
                    break;
                auto restCont = args;
                restCont.erase(*it);
                auto restCond = logical_and(restCont);
                map_basic_basic d;
                bool symexists = false;
                for (const auto &fselement : fset) {
                    d[sym] = fselement;
                    auto contain = restCond->subs(d);
                    if (eq(*contain, *boolean(true))) {
                        present.insert(fselement);
                    } else if (not eq(*contain, *boolean(false))) {
                        present.insert(fselement);
                        symexists = true;
                    }
                    d.clear();
                }
                if (not symexists) {
                    // if there are no symbols, then this reduces to a
                    // Contains(sym,finiteset())
                    return finiteset(present)->contains(sym);
                } else if (present.size() != fset.size()) {
                    restCond = logical_and(
                        {finiteset(present)->contains(sym), restCond});
                    return restCond;
                } else {
                    // if present is same as fset, then return object of type
                    // `And`.
                    break;
                }
            }
        }
    }
    if (args.size() == 1)
        return *(args.begin());
    else if (args.size() == 0)
        return boolean(not op_x_notx);
    return make_rcp<const caller>(args);
}

and_tribool()

tribool SymEngine::and_tribool ( tribool  a, tribool  b  )

inline

Definition at line 29 of file tribool.h.

{
    if (!(static_cast<unsigned>(a) & static_cast<unsigned>(b))) {
        return tribool::trifalse;
    } else {
        return static_cast<tribool>(static_cast<unsigned>(a)
                                    | static_cast<unsigned>(b));
    }
}

andwk_tribool()

tribool SymEngine::andwk_tribool ( tribool  a, tribool  b  )

inline

Definition at line 61 of file tribool.h.

{
    if (is_indeterminate(a) || is_indeterminate(b)) {
        return tribool::indeterminate;
    } else {
        return static_cast<tribool>(static_cast<unsigned>(a)
                                    && static_cast<unsigned>(b));
    }
}

as_numer_denom()

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

Definition at line 133 of file numer_denom.cpp.

{
    NumerDenomVisitor v(numer, denom);
    v.apply(*x);
}

as_real_imag()

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

Definition at line 282 of file as_real_imag.cpp.

{
    RealImagVisitor v(real, imag);
    v.apply(*x);
}

ascii_art()

std::string SymEngine::ascii_art

(

)

Definition at line 18 of file strprinter.cpp.

{
    std::string a = " _____           _____         _         \n"
                    "|   __|_ _ _____|   __|___ ___|_|___ ___ \n"
                    "|__   | | |     |   __|   | . | |   | -_|\n"
                    "|_____|_  |_|_|_|_____|_|_|_  |_|_|_|___|\n"
                    "      |___|               |___|          \n";
    return a;
}

asec()

RCP< const Basic > SymEngine::asec

(

const RCP< const Basic > &

arg

)

Canonicalize ASec:

Definition at line 1444 of file functions.cpp.

{
    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().asec(*arg);
    }
 
    RCP<const Basic> index;
    bool b = inverse_lookup(inverse_cst(), div(one, arg), outArg(index));
    if (b) {
        return sub(div(pi, i2), div(pi, index));
    } else {
        return make_rcp<const ASec>(arg);
    }
}

asech()

RCP< const Basic > SymEngine::asech

(

const RCP< const Basic > &

arg

)

Canonicalize ASech:

Definition at line 2571 of file functions.cpp.

{
    // TODO: Lookup into a cst table once complex is implemented
    if (eq(*arg, *one))
        return zero;
    if (eq(*arg, *zero))
        return Inf;
    if (is_a_Number(*arg)) {
        RCP<const Number> _arg = rcp_static_cast<const Number>(arg);
        if (not _arg->is_exact()) {
            return _arg->get_eval().asech(*_arg);
        }
    }
    return make_rcp<const ASech>(arg);
}

asin()

RCP< const Basic > SymEngine::asin

(

const RCP< const Basic > &

arg

)

Canonicalize ASin:

Definition at line 1360 of file functions.cpp.

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

asinh()

RCP< const Basic > SymEngine::asinh

(

const RCP< const Basic > &

arg

)

Canonicalize ASinh:

Definition at line 2376 of file functions.cpp.

{
    if (eq(*arg, *zero))
        return zero;
    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().asinh(*_arg);
        } else if (_arg->is_negative()) {
            return neg(asinh(zero->sub(*_arg)));
        }
    }
    RCP<const Basic> d;
    bool b = handle_minus(arg, outArg(d));
    if (b) {
        return neg(asinh(d));
    }
    return make_rcp<const ASinh>(d);
}

atan()

RCP< const Basic > SymEngine::atan

(

const RCP< const Basic > &

arg

)

Canonicalize ATan:

Definition at line 1524 of file functions.cpp.

{
    if (eq(*arg, *zero))
        return zero;
    else if (eq(*arg, *one))
        return div(pi, mul(i2, i2));
    else if (eq(*arg, *minus_one))
        return mul(minus_one, 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().atan(*arg);
    }
 
    RCP<const Basic> index;
    bool b = inverse_lookup(inverse_tct(), arg, outArg(index));
    if (b) {
        return div(pi, index);
    } else {
        return make_rcp<const ATan>(arg);
    }
}

atan2()

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

Canonicalize ATan2:

Definition at line 1614 of file functions.cpp.

{
    if (eq(*num, *zero)) {
        if (is_a_Number(*den)) {
            RCP<const Number> den_new = rcp_static_cast<const Number>(den);
            if (den_new->is_negative())
                return pi;
            else if (den_new->is_positive())
                return zero;
            else {
                return Nan;
            }
        }
    } else if (eq(*den, *zero)) {
        if (is_a_Number(*num)) {
            RCP<const Number> num_new = rcp_static_cast<const Number>(num);
            if (num_new->is_negative())
                return div(pi, im2);
            else
                return div(pi, i2);
        }
    }
    RCP<const Basic> index;
    bool b = inverse_lookup(inverse_tct(), div(num, den), outArg(index));
    if (b) {
        // Ideally the answer should depend on the signs of `num` and `den`
        // Currently is_positive() and is_negative() is not implemented for
        // types other than `Number`
        // Hence this will give exact answers in case when num and den are
        // numbers in SymEngine sense and when num and den are positive.
        // for the remaining cases in which we just return the value from
        // the lookup table.
        // TODO: update once is_positive() and is_negative() is implemented
        // in `Basic`
        if (is_a_Number(*den) and is_a_Number(*num)) {
            RCP<const Number> den_new = rcp_static_cast<const Number>(den);
            RCP<const Number> num_new = rcp_static_cast<const Number>(num);
 
            if (den_new->is_positive()) {
                return div(pi, index);
            } else if (den_new->is_negative()) {
                if (num_new->is_negative()) {
                    return sub(div(pi, index), pi);
                } else {
                    return add(div(pi, index), pi);
                }
            } else {
                return div(pi, index);
            }
        } else {
            return div(pi, index);
        }
    } else {
        return make_rcp<const ATan2>(num, den);
    }
}

atanh()

RCP< const Basic > SymEngine::atanh

(

const RCP< const Basic > &

arg

)

Canonicalize ATanh:

Definition at line 2494 of file functions.cpp.

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

atoms()

template<typename... Args>

set_basic SymEngine::atoms ( const Basic &  b )

inline

Definition at line 313 of file visitor.h.

{
    AtomsVisitor<Args...> visitor;
    return visitor.apply(b);
};

back_substitution()

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

Definition at line 1145 of file dense_matrix.cpp.

{
    SYMENGINE_ASSERT(U.row_ == U.col_);
    SYMENGINE_ASSERT(b.row_ == U.row_);
    SYMENGINE_ASSERT(x.row_ == U.col_ and x.col_ == b.col_);
 
    const unsigned col = U.col_;
    const unsigned sys = b.col_;
    x.m_ = b.m_;
 
    for (unsigned k = 0; k < sys; k++) {
        for (int i = col - 1; i >= 0; i--) {
            for (unsigned j = i + 1; j < col; j++)
                x.m_[i * sys + k]
                    = sub(x.m_[i * sys + k],
                          mul(U.m_[i * col + j], x.m_[j * sys + k]));
            x.m_[i * sys + k] = div(x.m_[i * sys + k], U.m_[i * col + i]);
        }
    }
}

berkowitz()

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

Definition at line 1755 of file dense_matrix.cpp.

{
    SYMENGINE_ASSERT(A.row_ == A.col_);
 
    unsigned col = A.col_;
    unsigned i, k, l, m;
 
    std::vector<DenseMatrix> items;
    std::vector<DenseMatrix> transforms;
    std::vector<RCP<const Basic>> items_;
 
    for (unsigned n = col; n > 1; n--) {
        items.clear();
        k = n - 1;
        DenseMatrix T = DenseMatrix(n + 1, n);
        DenseMatrix C = DenseMatrix(k, 1);
 
        // Initialize T and C
        for (i = 0; i < n * (n + 1); i++)
            T.m_[i] = zero;
        for (i = 0; i < k; i++)
            C.m_[i] = A.m_[i * col + k];
        items.push_back(C);
 
        for (i = 0; i < n - 2; i++) {
            DenseMatrix B = DenseMatrix(k, 1);
            for (l = 0; l < k; l++) {
                B.m_[l] = zero;
                for (m = 0; m < k; m++)
                    B.m_[l]
                        = add(B.m_[l], mul(A.m_[l * col + m], items[i].m_[m]));
            }
            items.push_back(B);
        }
 
        items_.clear();
        for (i = 0; i < n - 1; i++) {
            RCP<const Basic> element = zero;
            for (l = 0; l < k; l++)
                element = add(element, mul(A.m_[k * col + l], items[i].m_[l]));
            items_.push_back(mul(minus_one, element));
        }
        items_.insert(items_.begin(), mul(minus_one, A.m_[k * col + k]));
        items_.insert(items_.begin(), one);
 
        for (i = 0; i < n; i++) {
            for (l = 0; l < n - i + 1; l++)
                T.m_[(i + l) * n + i] = items_[l];
        }
 
        transforms.push_back(T);
    }
 
    polys.push_back(DenseMatrix(2, 1, {one, mul(A.m_[0], minus_one)}));
 
    for (i = 0; i < col - 1; i++) {
        unsigned t_row = transforms[col - 2 - i].nrows();
        unsigned t_col = transforms[col - 2 - i].ncols();
        DenseMatrix B = DenseMatrix(t_row, 1);
 
        for (l = 0; l < t_row; l++) {
            B.m_[l] = zero;
            for (m = 0; m < t_col; m++) {
                B.m_[l] = add(B.m_[l],
                              mul(transforms[col - 2 - i].m_[l * t_col + m],
                                  polys[i].m_[m]));
                B.m_[l] = expand(B.m_[l]);
            }
        }
        polys.push_back(B);
    }
}

bernoulli()

RCP< const Number > SymEngine::bernoulli

(

unsigned long

n

)

Computes the Bernoulli number Bn as an exact fraction, for an isolated integer n

Definition at line 495 of file ntheory.cpp.

{
#ifdef HAVE_SYMENGINE_ARB
    fmpq_t res;
    fmpq_init(res);
    bernoulli_fmpq_ui(res, n);
    mpq_t a;
    mpq_init(a);
    fmpq_get_mpq(a, res);
    rational_class b(a);
    fmpq_clear(res);
    mpq_clear(a);
    return Rational::from_mpq(std::move(b));
#else
    // TODO: implement a faster algorithm
    std::vector<rational_class> v(n + 1);
    for (unsigned m = 0; m <= n; ++m) {
        v[m] = rational_class(1u, m + 1);
 
        for (unsigned j = m; j >= 1; --j) {
            v[j - 1] = j * (v[j - 1] - v[j]);
        }
    }
    return Rational::from_mpq(v[0]);
#endif
}

beta()

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

Canonicalize Beta:

Definition at line 3283 of file functions.cpp.

{
    // Only special values are being evaluated
    if (eq(*add(x, y), *one)) {
        return ComplexInf;
    }
 
    if (is_a<Integer>(*x)) {
        RCP<const Integer> x_int = rcp_static_cast<const Integer>(x);
        if (x_int->is_positive()) {
            if (is_a<Integer>(*y)) {
                RCP<const Integer> y_int = rcp_static_cast<const Integer>(y);
                if (y_int->is_positive()) {
                    return div(
                        mul(gamma_positive_int(x), gamma_positive_int(y)),
                        gamma_positive_int(add(x, y)));
                } else {
                    return ComplexInf;
                }
            } else if (is_a<Rational>(*y)) {
                RCP<const Rational> y_ = rcp_static_cast<const Rational>(y);
                if (get_den(y_->as_rational_class()) == 2) {
                    return div(mul(gamma_positive_int(x), gamma_multiple_2(y)),
                               gamma_multiple_2(add(x, y)));
                } else {
                    return Beta::from_two_basic(x, y);
                }
            }
        } else {
            return ComplexInf;
        }
    }
 
    if (is_a<Integer>(*y)) {
        RCP<const Integer> y_int = rcp_static_cast<const Integer>(y);
        if (y_int->is_positive()) {
            if (is_a<Rational>(*x)) {
                RCP<const Rational> x_ = rcp_static_cast<const Rational>(x);
                if (get_den(x_->as_rational_class()) == 2) {
                    return div(mul(gamma_positive_int(y), gamma_multiple_2(x)),
                               gamma_multiple_2(add(x, y)));
                } else {
                    return Beta::from_two_basic(x, y);
                }
            }
        } else {
            return ComplexInf;
        }
    }
 
    if (is_a<const Rational>(*x)
        and get_den(down_cast<const Rational &>(*x).as_rational_class()) == 2) {
        if (is_a<Integer>(*y)) {
            RCP<const Integer> y_int = rcp_static_cast<const Integer>(y);
            if (y_int->is_positive()) {
                return div(mul(gamma_multiple_2(x), gamma_positive_int(y)),
                           gamma_multiple_2(add(x, y)));
            } else {
                return ComplexInf;
            }
        }
        if (is_a<const Rational>(*y)
            and get_den((down_cast<const Rational &>(*y)).as_rational_class())
                    == 2) {
            return div(mul(gamma_multiple_2(x), gamma_multiple_2(y)),
                       gamma_positive_int(add(x, y)));
        }
    }
    return Beta::from_two_basic(x, y);
}

binomial()

RCP< const Integer > SymEngine::binomial	(	const Integer &	n,
		unsigned long	k
	)

Binomial Coefficient.

Definition at line 145 of file ntheory.cpp.

{
    integer_class f;
    mp_bin_ui(f, n.as_integer_class(), k);
    return integer(std::move(f));
}

bit_length()

template<typename T >

unsigned int SymEngine::bit_length

(

T

t

)

Definition at line 14 of file uintpoly.h.

{
    unsigned int count = 0;
    while (t > 0) {
        count++;
        t = t >> 1;
    }
    return count;
}

boolean()

RCP< const BooleanAtom > SymEngine::boolean ( bool  b )

inline

Definition at line 46 of file logic.h.

{
    return b ? boolTrue : boolFalse;
}

boundary()

RCP< const Set > SymEngine::boundary

(

const Set &

s

)

Definition at line 277 of file set_funcs.cpp.

{
    BoundaryVisitor visitor;
    return visitor.apply(s);
}

c89code()

std::string SymEngine::c89code ( const Basic &  x )

inline

Definition at line 359 of file codegen.cpp.

{
    C89CodePrinter p;
    return p.apply(x);
}

c99code()

std::string SymEngine::c99code ( const Basic &  x )

inline

Definition at line 365 of file codegen.cpp.

{
    C99CodePrinter p;
    return p.apply(x);
}

cancel()

template<typename Poly >

void SymEngine::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  )

inline

Definition at line 11 of file cancel.h.

{
    // Converting basic to Poly
    umap_basic_num numer_gens = _find_gens_poly(numer);
    umap_basic_num denom_gens = _find_gens_poly(denom);
 
    if (numer_gens.size() != 1 && denom_gens.size() != 1) {
        // only considering univariate here
        return;
    }
    RCP<const Basic> numer_var = numer_gens.begin()->first;
    RCP<const Basic> denom_var = denom_gens.begin()->first;
 
    RCP<const Poly> numer_poly = from_basic<Poly>(numer, numer_var);
    RCP<const Poly> denom_poly = from_basic<Poly>(denom, denom_var);
 
    // Finding common factors of numer_poly and denom_poly
    RCP<const Poly> gcd_poly = gcd_upoly(*numer_poly, *denom_poly);
 
    // Dividing both by common factors
    divides_upoly(*gcd_poly, *numer_poly, outArg(*result_numer));
    divides_upoly(*gcd_poly, *denom_poly, outArg(*result_denom));
    *common = gcd_poly;
}

canonicalize()

void SymEngine::canonicalize ( rational_class &  i )

inline

Definition at line 291 of file mp_class.h.

{
    i.canonicalize();
}

carmichael()

RCP< const Integer > SymEngine::carmichael

(

const RCP< const Integer > &

n

)

Carmichael function.

Definition at line 812 of file ntheory.cpp.

{
    if (n->is_zero())
        return integer(1);
 
    map_integer_uint prime_mul;
    integer_class lambda, t, p;
    unsigned multiplicity;
 
    prime_factor_multiplicities(prime_mul, *n);
    lambda = 1;
    for (const auto &it : prime_mul) {
        p = it.first->as_integer_class();
        multiplicity = it.second;
        if (p == 2
            and multiplicity
                    > 2) { // For powers of 2 greater than 4 divide by 2.
            multiplicity--;
        }
        t = p - 1;
        mp_lcm(lambda, lambda, t);
        mp_pow_ui(t, p, multiplicity - 1);
        // lambda and p are relatively prime.
        lambda = lambda * t;
    }
    return integer(std::move(lambda));
}

cbrt() [1/2]

RCP< const Basic > SymEngine::cbrt ( const RCP< const Basic > &  x )

inline

Returns

cbrt of the arg

cube root of x

Definition at line 66 of file pow.h.

{
    return pow(x, div(one, integer(3)));
}

cbrt() [2/2]

RCP< const Basic > SymEngine::cbrt

(

RCP< const Basic > &

arg

)

Definition at line 18 of file functions.cpp.

{
    return pow(arg, div(one, i3));
}

ccode()

std::string SymEngine::ccode

(

const Basic &

x

)

Definition at line 347 of file codegen.cpp.

{
    C99CodePrinter c;
    return c.apply(x);
}

ceiling()

RCP< const Basic > SymEngine::ceiling

(

const RCP< const Basic > &

arg

)

Canonicalize Ceiling:

Definition at line 705 of file functions.cpp.

{
    if (is_a_Number(*arg)) {
        if (down_cast<const Number &>(*arg).is_exact()) {
            if (is_a<Rational>(*arg)) {
                const Rational &s = down_cast<const Rational &>(*arg);
                integer_class quotient;
                mp_cdiv_q(quotient, SymEngine::get_num(s.as_rational_class()),
                          SymEngine::get_den(s.as_rational_class()));
                return integer(std::move(quotient));
            }
            return arg;
        }
        RCP<const Number> _arg = rcp_static_cast<const Number>(arg);
        return _arg->get_eval().ceiling(*_arg);
    }
    if (is_a<Constant>(*arg)) {
        if (eq(*arg, *pi)) {
            return integer(4);
        }
        if (eq(*arg, *E)) {
            return integer(3);
        }
        if (eq(*arg, *GoldenRatio)) {
            return integer(2);
        }
        if (eq(*arg, *Catalan) or eq(*arg, *EulerGamma)) {
            return integer(1);
        }
    }
    if (is_a<Floor>(*arg)) {
        return arg;
    }
    if (is_a<Ceiling>(*arg)) {
        return arg;
    }
    if (is_a<Truncate>(*arg)) {
        return arg;
    }
    if (is_a<BooleanAtom>(*arg) or is_a_Relational(*arg)) {
        throw SymEngineException(
            "Boolean objects not allowed in this context.");
    }
    if (is_a<Add>(*arg)) {
        RCP<const Number> s = down_cast<const Add &>(*arg).get_coef();
        umap_basic_num d = down_cast<const Add &>(*arg).get_dict();
        if (is_a<Integer>(*s)) {
            return add(
                s, make_rcp<const Ceiling>(Add::from_dict(zero, std::move(d))));
        }
    }
    return make_rcp<const Ceiling>(arg);
}

CEREAL_LOAD_FUNCTION_NAME()

template<class Archive , class T >

void SymEngine::CEREAL_LOAD_FUNCTION_NAME ( Archive &  ar, RCP< const T > &  ptr  )

inline

Loading for SymEngine::RCP.

Definition at line 666 of file serialize-cereal.h.

{
    uint32_t id;
    ar(CEREAL_NVP(id));
 
    if (id & cereal::detail::msb_32bit) {
        TypeID type_code;
        ar(type_code);
        switch (type_code) {
#define SYMENGINE_ENUM(type_enum, Class)                                       \
    case type_enum: {                                                          \
        if (not std::is_base_of<T, Class>::value) {                            \
            throw std::runtime_error("Cannot convert to type.");               \
        } else {                                                               \
            RCP<const Class> dummy_ptr;                                        \
            ptr = rcp_static_cast<const T>(                                    \
                rcp_static_cast<const Basic>(load_basic(ar, dummy_ptr)));      \
            break;                                                             \
        }                                                                      \
    }
#include "symengine/type_codes.inc"
#undef SYMENGINE_ENUM
            default:
                throw std::runtime_error("Unknown type");
        }
        std::shared_ptr<void> sharedPtr = std::static_pointer_cast<void>(
            std::make_shared<RCP<const Basic>>(ptr));
 
        ar.registerSharedPointer(id, sharedPtr);
    } else {
        std::shared_ptr<RCP<const T>> sharedPtr
            = std::static_pointer_cast<RCP<const T>>(ar.getSharedPointer(id));
        ptr = *sharedPtr.get();
    }
}

CEREAL_SAVE_FUNCTION_NAME()

template<class Archive , class T >

void SymEngine::CEREAL_SAVE_FUNCTION_NAME ( Archive &  ar, RCP< const T > const &  ptr  )

inline

Saving for SymEngine::RCP.

Definition at line 309 of file serialize-cereal.h.

{
    save_basic(ar, rcp_static_cast<const Basic>(ptr));
}

char_poly()

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

Definition at line 1841 of file dense_matrix.cpp.

{
    SYMENGINE_ASSERT(B.ncols() == 1 and B.nrows() == A.nrows() + 1);
    SYMENGINE_ASSERT(A.nrows() == A.ncols());
 
    std::vector<DenseMatrix> polys;
 
    berkowitz(A, polys);
    B = polys[polys.size() - 1];
}

check_matching_mul_sizes()

void SymEngine::check_matching_mul_sizes

(

const vec_basic &

vec

)

Definition at line 152 of file matrix_mul.cpp.

{
    auto first_size = size(down_cast<const MatrixExpr &>(*vec[0]));
    for (size_t i = 1; i < vec.size(); i++) {
        auto second_size = size(down_cast<const MatrixExpr &>(*vec[i]));
        if (first_size.second.is_null() || second_size.first.is_null()) {
            first_size = second_size;
            continue;
        }
        auto diff = sub(first_size.second, second_size.first);
        tribool match = is_zero(*diff);
        if (is_false(match)) {
            throw DomainError("Matrix dimension mismatch");
        }
        first_size = second_size;
    }
}

check_matching_sizes()

void SymEngine::check_matching_sizes

(

const vec_basic &

vec

)

Definition at line 60 of file matrix_add.cpp.

{
    for (size_t i = 0; i < vec.size() - 1; i++) {
        auto first_size = size(down_cast<const MatrixExpr &>(*vec[i]));
        if (first_size.first.is_null()) {
            continue;
        }
        for (size_t j = 1; j < vec.size(); j++) {
            auto second_size = size(down_cast<const MatrixExpr &>(*vec[j]));
            if (second_size.first.is_null()) {
                continue;
            }
            auto rowdiff = sub(first_size.first, second_size.first);
            tribool rowmatch = is_zero(*rowdiff);
            if (is_false(rowmatch)) {
                throw DomainError("Matrix dimension mismatch");
            }
            auto coldiff = sub(first_size.second, second_size.second);
            tribool colmatch = is_zero(*coldiff);
            if (is_false(colmatch)) {
                throw DomainError("Matrix dimension mismatch");
            }
        }
    }
}

cholesky()

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

Definition at line 1638 of file dense_matrix.cpp.

{
    SYMENGINE_ASSERT(A.row_ == A.col_);
    SYMENGINE_ASSERT(L.row_ == A.row_ and L.col_ == A.row_);
 
    unsigned col = A.col_;
    unsigned i, j, k;
    RCP<const Basic> sum;
    RCP<const Basic> i2 = integer(2);
    RCP<const Basic> half = div(one, i2);
 
    // Initialize L
    for (i = 0; i < col; i++)
        for (j = 0; j < col; j++)
            L.m_[i * col + j] = zero;
 
    for (i = 0; i < col; i++) {
        for (j = 0; j < i; j++) {
            sum = zero;
            for (k = 0; k < j; k++)
                sum = add(sum, mul(L.m_[i * col + k], L.m_[j * col + k]));
 
            L.m_[i * col + j]
                = mul(div(one, L.m_[j * col + j]), sub(A.m_[i * col + j], sum));
        }
        sum = zero;
        for (k = 0; k < i; k++)
            sum = add(sum, pow(L.m_[i * col + k], i2));
        L.m_[i * col + i] = pow(sub(A.m_[i * col + i], sum), half);
    }
}

closure()

RCP< const Set > SymEngine::closure

(

const Set &

s

)

Definition at line 289 of file set_funcs.cpp.

{
    return s.set_union(boundary(s));
}

coeff()

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

Definition at line 63 of file visitor.cpp.

{
    if (!(is_a<Symbol>(x) || is_a<FunctionSymbol>(x))) {
        throw NotImplementedError("Not implemented for non (Function)Symbols.");
    }
    CoeffVisitor v(ptrFromRef(x), ptrFromRef(n));
    return v.apply(b);
}

column_exchange_dense()

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

Definition at line 864 of file dense_matrix.cpp.

{
    SYMENGINE_ASSERT(i != j and i < A.col_ and j < A.col_);
 
    unsigned col = A.col_;
 
    for (unsigned k = 0; k < A.row_; k++)
        std::swap(A.m_[k * col + i], A.m_[k * col + j]);
}

complex_double()

RCP< const ComplexDouble > SymEngine::complex_double

(

std::complex< double >

x

)

Definition at line 62 of file complex_double.cpp.

{
    return make_rcp<const ComplexDouble>(x);
}

complexes()

RCP< const Complexes > SymEngine::complexes ( )

inline

Returns

RCP<const Complexes>

Definition at line 554 of file sets.h.

{
    return Complexes::getInstance();
}

conditionset()

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

Returns

RCP<const Set>

Definition at line 1781 of file sets.cpp.

{
    if (eq(*condition, *boolean(false))) {
        return emptyset();
    } else if (eq(*condition, *boolean(true))) {
        return universalset();
    }
    if (is_a<And>(*condition)) {
        auto cont = down_cast<const And &>(*condition).get_container();
        set_boolean newcont;
        set_basic present, others;
        for (auto it = cont.begin(); it != cont.end(); it++) {
            if (is_a<Contains>(**it)
                and eq(*down_cast<const Contains &>(**it).get_expr(), *sym)
                and is_a<FiniteSet>(
                    *down_cast<const Contains &>(**it).get_set())) {
                auto fset = down_cast<const Contains &>(**it).get_set();
                auto fcont
                    = down_cast<const FiniteSet &>(*fset).get_container();
                // use the result of simplification done in `logical_and()`
                for (const auto &elem : fcont) {
                    if (not(is_a_Number(*elem) or is_a<Constant>(*elem))) {
                        others.insert(elem);
                    } else {
                        // logical_and() doesn't guarantee that if element of a
                        // finiteset is a number, then it satisfies other
                        // conditions
                        // it only assures that there doesn't exist any such
                        // element of finiteset that surely fails in other
                        // conditions.
                        auto restCont = cont;
                        restCont.erase(*it);
                        auto restCond = logical_and(restCont);
                        map_basic_basic d;
                        d[sym] = elem;
                        auto contain = restCond->subs(d);
                        if (eq(*contain, *boolean(true))) {
                            present.insert(elem);
                        } else if (not eq(*contain, *boolean(false))) {
                            others.insert(elem);
                        } else {
                            throw SymEngineException("element should have "
                                                     "been removed within "
                                                     "logical_and()");
                        }
                    }
                }
            } else {
                newcont.insert(*it);
            }
        }
        if (not present.empty()) {
            newcont.insert(finiteset(others)->contains(sym));
            return SymEngine::set_union(
                {finiteset(present), conditionset(sym, logical_and(newcont))});
        }
    }
    if (is_a<Contains>(*condition)) {
        return down_cast<const Contains &>(*condition).get_set();
    }
    return make_rcp<const ConditionSet>(sym, condition);
}

conjugate()

RCP< const Basic > SymEngine::conjugate

(

const RCP< const Basic > &

arg

)

Canonicalize Conjugate.

Definition at line 149 of file functions.cpp.

{
    if (is_a_Number(*arg)) {
        return down_cast<const Number &>(*arg).conjugate();
    }
    if (is_a<Constant>(*arg) or is_a<Abs>(*arg) or is_a<KroneckerDelta>(*arg)
        or is_a<LeviCivita>(*arg)) {
        return arg;
    }
    if (is_a<Mul>(*arg)) {
        const map_basic_basic &dict = down_cast<const Mul &>(*arg).get_dict();
        map_basic_basic new_dict;
        RCP<const Number> coef = rcp_static_cast<const Number>(
            conjugate(down_cast<const Mul &>(*arg).get_coef()));
        for (const auto &p : dict) {
            if (is_a<Integer>(*p.second)) {
                Mul::dict_add_term_new(outArg(coef), new_dict, p.second,
                                       conjugate(p.first));
            } else {
                Mul::dict_add_term_new(
                    outArg(coef), new_dict, one,
                    conjugate(Mul::from_dict(one, {{p.first, p.second}})));
            }
        }
        return Mul::from_dict(coef, std::move(new_dict));
    }
    if (is_a<Pow>(*arg)) {
        RCP<const Basic> base = down_cast<const Pow &>(*arg).get_base();
        RCP<const Basic> exp = down_cast<const Pow &>(*arg).get_exp();
        if (is_a<Integer>(*exp)) {
            return pow(conjugate(base), exp);
        }
    }
    if (is_a<Conjugate>(*arg)) {
        return down_cast<const Conjugate &>(*arg).get_arg();
    }
    if (is_a<Sign>(*arg) or is_a<Erf>(*arg) or is_a<Erfc>(*arg)
        or is_a<Gamma>(*arg) or is_a<LogGamma>(*arg) or is_a<Sin>(*arg)
        or is_a<Cos>(*arg) or is_a<Tan>(*arg) or is_a<Cot>(*arg)
        or is_a<Sec>(*arg) or is_a<Csc>(*arg) or is_a<Sinh>(*arg)
        or is_a<Cosh>(*arg) or is_a<Tanh>(*arg) or is_a<Coth>(*arg)
        or is_a<Sech>(*arg) or is_a<Csch>(*arg)) {
        const OneArgFunction &func = down_cast<const OneArgFunction &>(*arg);
        return func.create(conjugate(func.get_arg()));
    }
    if (is_a<ATan2>(*arg) or is_a<LowerGamma>(*arg) or is_a<UpperGamma>(*arg)
        or is_a<Beta>(*arg)) {
        const TwoArgFunction &func = down_cast<const TwoArgFunction &>(*arg);
        return func.create(conjugate(func.get_arg1()),
                           conjugate(func.get_arg2()));
    }
    return make_rcp<const Conjugate>(arg);
}

conjugate_dense()

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

Definition at line 603 of file dense_matrix.cpp.

{
    SYMENGINE_ASSERT(B.col_ == A.col_ and B.row_ == A.row_);
 
    for (unsigned i = 0; i < A.row_; i++)
        for (unsigned j = 0; j < A.col_; j++)
            B.m_[i * B.col_ + j] = conjugate(A.m_[i * A.col_ + j]);
}

conjugate_matrix()

RCP< const MatrixExpr > SymEngine::conjugate_matrix

(

const RCP< const MatrixExpr > &

arg

)

Definition at line 134 of file conjugate_matrix.cpp.

{
    ConjugateMatrixVisitor visitor;
    return visitor.apply(*arg);
}

conjugate_transpose_dense()

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

Definition at line 623 of file dense_matrix.cpp.

{
    SYMENGINE_ASSERT(B.row_ == A.col_ and B.col_ == A.row_);
 
    for (unsigned i = 0; i < A.row_; i++)
        for (unsigned j = 0; j < A.col_; j++)
            B.m_[j * B.col_ + i] = conjugate(A.m_[i * A.col_ + j]);
}

constant()

RCP< const Constant > SymEngine::constant ( const std::string &  name )

inline

inline version to return Constant

Definition at line 53 of file constants.h.

{
    return make_rcp<const Constant>(name);
}

contains()

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

Definition at line 116 of file logic.cpp.

{
    if (is_a_Number(*expr) or is_a_Set(*expr)) {
        return set->contains(expr);
    } else {
        return make_rcp<Contains>(expr, set);
    }
}

cos()

RCP< const Basic > SymEngine::cos

(

const RCP< const Basic > &

arg

)

Canonicalize Cos:

Definition at line 942 of file functions.cpp.

{
    if (eq(*arg, *zero))
        return one;
    if (is_a_Number(*arg) and not down_cast<const Number &>(*arg).is_exact()) {
        return down_cast<const Number &>(*arg).get_eval().cos(*arg);
    }
 
    if (is_a<ACos>(*arg)) {
        return down_cast<const ACos &>(*arg).get_arg();
    } else if (is_a<ASec>(*arg)) {
        return div(one, down_cast<const ASec &>(*arg).get_arg());
    }
 
    RCP<const Basic> ret_arg;
    int index, sign;
    bool conjugate = trig_simplify(arg, 2, false, true,           // input
                                   outArg(ret_arg), index, sign); // output
 
    if (conjugate) {
        // sin has to be returned
        if (sign == 1) {
            return sin(ret_arg);
        } else {
            return mul(minus_one, sin(ret_arg));
        }
    } else {
        if (eq(*ret_arg, *zero)) {
            return mul(integer(sign), sin_table()[(index + 6) % 24]);
        } else {
            if (sign == 1) {
                if (neq(*ret_arg, *arg)) {
                    return cos(ret_arg);
                } else {
                    return make_rcp<const Cos>(ret_arg);
                }
            } else {
                return mul(minus_one, cos(ret_arg));
            }
        }
    }
}

cosh()

RCP< const Basic > SymEngine::cosh

(

const RCP< const Basic > &

arg

)

Canonicalize Cosh:

Definition at line 2212 of file functions.cpp.

{
    if (eq(*arg, *zero))
        return 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().cosh(*_arg);
        } else if (_arg->is_negative()) {
            return cosh(zero->sub(*_arg));
        }
    }
    RCP<const Basic> d;
    handle_minus(arg, outArg(d));
    return make_rcp<const Cosh>(d);
}

cot()

RCP< const Basic > SymEngine::cot

(

const RCP< const Basic > &

arg

)

Canonicalize Cot:

Definition at line 1073 of file functions.cpp.

{
    if (is_a_Number(*arg) and not down_cast<const Number &>(*arg).is_exact()) {
        return down_cast<const Number &>(*arg).get_eval().cot(*arg);
    }
 
    if (is_a<ACot>(*arg)) {
        return down_cast<const ACot &>(*arg).get_arg();
    } else if (is_a<ATan>(*arg)) {
        return div(one, down_cast<const ATan &>(*arg).get_arg());
    }
 
    RCP<const Basic> ret_arg;
    int index, sign;
    bool conjugate = trig_simplify(arg, 1, true, true,            // input
                                   outArg(ret_arg), index, sign); // output
 
    if (conjugate) {
        // tan has to be returned
        if (sign == 1) {
            return tan(ret_arg);
        } else {
            return mul(minus_one, tan(ret_arg));
        }
    } else {
        if (eq(*ret_arg, *zero)) {
            return mul(integer(sign),
                       div(sin_table()[(index + 6) % 24], sin_table()[index]));
        } else {
            if (sign == 1) {
                if (neq(*ret_arg, *arg)) {
                    return cot(ret_arg);
                } else {
                    return make_rcp<const Cot>(ret_arg);
                }
            } else {
                return mul(minus_one, cot(ret_arg));
            }
        }
    }
}

coth()

RCP< const Basic > SymEngine::coth

(

const RCP< const Basic > &

arg

)

Canonicalize Coth:

Definition at line 2333 of file functions.cpp.

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

could_extract_minus()

bool SymEngine::could_extract_minus

(

const Basic &

arg

)

Returns

true if arg contains a negative sign.

Definition at line 325 of file functions.cpp.

{
    if (is_a_Number(arg)) {
        if (down_cast<const Number &>(arg).is_negative()) {
            return true;
        } else if (is_a_Complex(arg)) {
            const ComplexBase &c = down_cast<const ComplexBase &>(arg);
            RCP<const Number> real_part = c.real_part();
            return (real_part->is_negative())
                   or (eq(*real_part, *zero)
                       and c.imaginary_part()->is_negative());
        } else {
            return false;
        }
    } else if (is_a<Mul>(arg)) {
        const Mul &s = down_cast<const Mul &>(arg);
        return could_extract_minus(*s.get_coef());
    } else if (is_a<Add>(arg)) {
        const Add &s = down_cast<const Add &>(arg);
        if (s.get_coef()->is_zero()) {
            map_basic_num d(s.get_dict().begin(), s.get_dict().end());
            return could_extract_minus(*d.begin()->second);
        } else {
            return could_extract_minus(*s.get_coef());
        }
    } else {
        return false;
    }
}

count_ops()

unsigned SymEngine::count_ops

(

const vec_basic &

a

)

Definition at line 314 of file visitor.cpp.

{
    CountOpsVisitor v;
    for (auto &p : a) {
        v.apply(*p);
    }
    return v.count;
}

cross()

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

Definition at line 1962 of file dense_matrix.cpp.

{
    SYMENGINE_ASSERT((A.row_ * A.col_ == 3 and B.row_ * B.col_ == 3)
                     and (A.row_ == C.row_ and A.col_ == C.col_));
 
    C.m_[0] = sub(mul(A.m_[1], B.m_[2]), mul(A.m_[2], B.m_[1]));
    C.m_[1] = sub(mul(A.m_[2], B.m_[0]), mul(A.m_[0], B.m_[2]));
    C.m_[2] = sub(mul(A.m_[0], B.m_[1]), mul(A.m_[1], B.m_[0]));
}

crt()

bool SymEngine::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.

Definition at line 552 of file ntheory.cpp.

{
    if (mod.size() > rem.size())
        throw SymEngineException("Too few remainders");
    if (mod.size() == 0)
        throw SymEngineException("Moduli vector cannot be empty");
 
    integer_class m, r, g, s, t;
    m = mod[0]->as_integer_class();
    r = rem[0]->as_integer_class();
 
    for (unsigned i = 1; i < mod.size(); ++i) {
        mp_gcdext(g, s, t, m, mod[i]->as_integer_class());
        // g = s * m + t * mod[i]
        t = rem[i]->as_integer_class() - r;
        if (not mp_divisible_p(t, g))
            return false;
        r += m * s * (t / g); // r += m * (m**-1 mod[i]/g)* (rem[i] - r) / g
        m *= mod[i]->as_integer_class() / g;
        mp_fdiv_r(r, r, m);
    }
    *R = integer(std::move(r));
    return true;
}

csc()

RCP< const Basic > SymEngine::csc

(

const RCP< const Basic > &

arg

)

Canonicalize Csc:

Definition at line 1138 of file functions.cpp.

{
    if (is_a_Number(*arg) and not down_cast<const Number &>(*arg).is_exact()) {
        return down_cast<const Number &>(*arg).get_eval().csc(*arg);
    }
 
    if (is_a<ACsc>(*arg)) {
        return down_cast<const ACsc &>(*arg).get_arg();
    } else if (is_a<ASin>(*arg)) {
        return div(one, down_cast<const ASin &>(*arg).get_arg());
    }
 
    RCP<const Basic> ret_arg;
    int index, sign;
    bool conjugate = trig_simplify(arg, 2, true, false,           // input
                                   outArg(ret_arg), index, sign); // output
 
    if (conjugate) {
        // cos has to be returned
        if (sign == 1) {
            return sec(ret_arg);
        } else {
            return mul(minus_one, sec(ret_arg));
        }
    } else {
        if (eq(*ret_arg, *zero)) {
            return mul(integer(sign), div(one, sin_table()[index]));
        } else {
            if (sign == 1) {
                if (neq(*ret_arg, *arg)) {
                    return csc(ret_arg);
                } else {
                    return make_rcp<const Csc>(ret_arg);
                }
            } else {
                return mul(minus_one, csc(ret_arg));
            }
        }
    }
}

csch()

RCP< const Basic > SymEngine::csch

(

const RCP< const Basic > &

arg

)

Canonicalize Csch:

Definition at line 2169 of file functions.cpp.

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

cse()

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

Definition at line 547 of file cse.cpp.

{
    // Find other optimization opportunities.
    umap_basic_basic opt_subs = opt_cse(exprs);
 
    // Main CSE algorithm.
    tree_cse(replacements, reduced_exprs, exprs, opt_subs);
}

csr_binop_csr_canonical()

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

Definition at line 689 of file sparse_matrix.cpp.

{
    SYMENGINE_ASSERT(A.row_ == B.row_ and A.col_ == B.col_ and C.row_ == A.row_
                     and C.col_ == A.col_);
 
    // Method that works for canonical CSR matrices
    C.p_[0] = 0;
    C.j_.clear();
    C.x_.clear();
    unsigned nnz = 0;
    unsigned A_pos, B_pos, A_end, B_end;
 
    for (unsigned i = 0; i < A.row_; i++) {
        A_pos = A.p_[i];
        B_pos = B.p_[i];
        A_end = A.p_[i + 1];
        B_end = B.p_[i + 1];
 
        // while not finished with either row
        while (A_pos < A_end and B_pos < B_end) {
            unsigned A_j = A.j_[A_pos];
            unsigned B_j = B.j_[B_pos];
 
            if (A_j == B_j) {
                RCP<const Basic> result = bin_op(A.x_[A_pos], B.x_[B_pos]);
                if (!is_true(is_zero(*result))) {
                    C.j_.push_back(A_j);
                    C.x_.push_back(result);
                    nnz++;
                }
                A_pos++;
                B_pos++;
            } else if (A_j < B_j) {
                RCP<const Basic> result = bin_op(A.x_[A_pos], zero);
                if (!is_true(is_zero(*result))) {
                    C.j_.push_back(A_j);
                    C.x_.push_back(result);
                    nnz++;
                }
                A_pos++;
            } else {
                // B_j < A_j
                RCP<const Basic> result = bin_op(zero, B.x_[B_pos]);
                if (!is_true(is_zero(*result))) {
                    C.j_.push_back(B_j);
                    C.x_.push_back(result);
                    nnz++;
                }
                B_pos++;
            }
        }
 
        // tail
        while (A_pos < A_end) {
            RCP<const Basic> result = bin_op(A.x_[A_pos], zero);
            if (!is_true(is_zero(*result))) {
                C.j_.push_back(A.j_[A_pos]);
                C.x_.push_back(result);
                nnz++;
            }
            A_pos++;
        }
        while (B_pos < B_end) {
            RCP<const Basic> result = bin_op(zero, B.x_[B_pos]);
            if (!is_true(is_zero(*result))) {
                C.j_.push_back(B.j_[B_pos]);
                C.x_.push_back(result);
                nnz++;
            }
            B_pos++;
        }
 
        C.p_[i + 1] = nnz;
    }
 
    // It's enough to check for duplicates as the column indices
    // remain sorted after the above operations
    if (CSRMatrix::csr_has_duplicates(C.p_, C.j_, A.row_))
        CSRMatrix::csr_sum_duplicates(C.p_, C.j_, C.x_, A.row_);
}

csr_diagonal()

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

Definition at line 622 of file sparse_matrix.cpp.

{
    unsigned N = std::min(A.row_, A.col_);
 
    SYMENGINE_ASSERT(D.nrows() == N and D.ncols() == 1);
 
    unsigned row_start;
    unsigned row_end;
    RCP<const Basic> diag;
 
    for (unsigned i = 0; i < N; i++) {
        row_start = A.p_[i];
        row_end = A.p_[i + 1];
        diag = zero;
        unsigned jj;
 
        while (row_start <= row_end) {
            jj = (row_start + row_end) / 2;
            if (A.j_[jj] == i) {
                diag = A.x_[jj];
                break;
            } else if (A.j_[jj] < i) {
                row_start = jj + 1;
            } else {
                row_end = jj - 1;
            }
        }
 
        D.set(i, 0, diag);
    }
}

csr_matmat_pass1()

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

Definition at line 532 of file sparse_matrix.cpp.

{
    // method that uses O(n) temp storage
    std::vector<unsigned> mask(A.col_, -1);
    C.p_[0] = 0;
 
    unsigned nnz = 0;
    for (unsigned i = 0; i < A.row_; i++) {
        // npy_intp row_nnz = 0;
        unsigned row_nnz = 0;
 
        for (unsigned jj = A.p_[i]; jj < A.p_[i + 1]; jj++) {
            unsigned j = A.j_[jj];
            for (unsigned kk = B.p_[j]; kk < B.p_[j + 1]; kk++) {
                unsigned k = B.j_[kk];
                if (mask[k] != i) {
                    mask[k] = i;
                    row_nnz++;
                }
            }
        }
 
        unsigned next_nnz = nnz + row_nnz;
 
        // Addition overflow: http://www.cplusplus.com/articles/DE18T05o/
        if (next_nnz < nnz) {
            throw std::overflow_error("nnz of the result is too large");
        }
 
        nnz = next_nnz;
        C.p_[i + 1] = nnz;
    }
}

csr_matmat_pass2()

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

Definition at line 568 of file sparse_matrix.cpp.

{
    std::vector<int> next(A.col_, -1);
    vec_basic sums(A.col_, zero);
 
    unsigned nnz = 0;
 
    C.p_[0] = 0;
 
    for (unsigned i = 0; i < A.row_; i++) {
        int head = -2;
        unsigned length = 0;
 
        unsigned jj_start = A.p_[i];
        unsigned jj_end = A.p_[i + 1];
        for (unsigned jj = jj_start; jj < jj_end; jj++) {
            unsigned j = A.j_[jj];
            RCP<const Basic> v = A.x_[jj];
 
            unsigned kk_start = B.p_[j];
            unsigned kk_end = B.p_[j + 1];
            for (unsigned kk = kk_start; kk < kk_end; kk++) {
                unsigned k = B.j_[kk];
 
                sums[k] = add(sums[k], mul(v, B.x_[kk]));
 
                if (next[k] == -1) {
                    next[k] = head;
                    head = k;
                    length++;
                }
            }
        }
 
        for (unsigned jj = 0; jj < length; jj++) {
 
            if (!is_true(is_zero(*sums[head]))) {
                C.j_[nnz] = head;
                C.x_[nnz] = sums[head];
                nnz++;
            }
 
            unsigned temp = head;
            head = next[head];
 
            next[temp] = -1; // clear arrays
            sums[temp] = zero;
        }
 
        C.p_[i + 1] = nnz;
    }
}

csr_scale_columns()

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

Definition at line 670 of file sparse_matrix.cpp.

{
    SYMENGINE_ASSERT(A.col_ == X.nrows() and X.ncols() == 1);
 
    const unsigned nnz = A.p_[A.row_];
    unsigned i;
 
    for (i = 0; i < A.col_; i++) {
        if (is_true(is_zero(*X.get(i, 0))))
            throw SymEngineException("Scaling factor can't be zero");
    }
 
    for (i = 0; i < nnz; i++)
        A.x_[i] = mul(A.x_[i], X.get(A.j_[i], 0));
}

csr_scale_rows()

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

Definition at line 656 of file sparse_matrix.cpp.

{
    SYMENGINE_ASSERT(A.row_ == X.nrows() and X.ncols() == 1);
 
    for (unsigned i = 0; i < A.row_; i++) {
        if (is_true(is_zero(*X.get(i, 0))))
            throw SymEngineException("Scaling factor can't be zero");
        for (unsigned jj = A.p_[i]; jj < A.p_[i + 1]; jj++)
            A.x_[jj] = mul(A.x_[jj], X.get(i, 0));
    }
}

det_bareis()

RCP< const Basic > SymEngine::det_bareis

(

const DenseMatrix &

A

)

Definition at line 1690 of file dense_matrix.cpp.

{
    SYMENGINE_ASSERT(A.row_ == A.col_);
 
    unsigned n = A.row_;
 
    if (n == 1) {
        return A.m_[0];
    } else if (n == 2) {
        // If A = [[a, b], [c, d]] then det(A) = ad - bc
        return sub(mul(A.m_[0], A.m_[3]), mul(A.m_[1], A.m_[2]));
    } else if (n == 3) {
        // if A = [[a, b, c], [d, e, f], [g, h, i]] then
        // det(A) = (aei + bfg + cdh) - (ceg + bdi + afh)
        return sub(add(add(mul(mul(A.m_[0], A.m_[4]), A.m_[8]),
                           mul(mul(A.m_[1], A.m_[5]), A.m_[6])),
                       mul(mul(A.m_[2], A.m_[3]), A.m_[7])),
                   add(add(mul(mul(A.m_[2], A.m_[4]), A.m_[6]),
                           mul(mul(A.m_[1], A.m_[3]), A.m_[8])),
                       mul(mul(A.m_[0], A.m_[5]), A.m_[7])));
    } else {
 
        if (A.is_lower() or A.is_upper()) {
            RCP<const Basic> det = A.m_[0];
            for (unsigned i = 1; i < n; ++i) {
                det = mul(det, A.m_[i * n + i]);
            }
            return det;
        }
 
        DenseMatrix B = DenseMatrix(n, n, A.m_);
        unsigned i, sign = 1;
        RCP<const Basic> d;
 
        for (unsigned k = 0; k < n - 1; k++) {
            if (is_true(is_zero(*B.m_[k * n + k]))) {
                for (i = k + 1; i < n; i++)
                    if (!is_true(is_zero(*B.m_[i * n + k]))) {
                        row_exchange_dense(B, i, k);
                        sign *= -1;
                        break;
                    }
                if (i == n)
                    return zero;
            }
 
            for (i = k + 1; i < n; i++) {
                for (unsigned j = k + 1; j < n; j++) {
                    d = sub(mul(B.m_[k * n + k], B.m_[i * n + j]),
                            mul(B.m_[i * n + k], B.m_[k * n + j]));
                    if (k > 0)
                        d = div(d, B.m_[(k - 1) * n + k - 1]);
                    B.m_[i * n + j] = d;
                }
            }
        }
 
        return (sign == 1) ? B.m_[n * n - 1] : mul(minus_one, B.m_[n * n - 1]);
    }
}

det_berkowitz()

RCP< const Basic > SymEngine::det_berkowitz

(

const DenseMatrix &

A

)

Definition at line 1828 of file dense_matrix.cpp.

{
    std::vector<DenseMatrix> polys;
 
    berkowitz(A, polys);
    DenseMatrix poly = polys[polys.size() - 1];
 
    if (polys.size() % 2 == 1)
        return mul(minus_one, poly.get(poly.nrows() - 1, 0));
 
    return poly.get(poly.nrows() - 1, 0);
}

diag()

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

Definition at line 2010 of file dense_matrix.cpp.

{
    SYMENGINE_ASSERT(v.size() > 0);
 
    unsigned k_ = std::abs(k);
 
    if (k >= 0) {
        for (unsigned i = 0; i < A.row_; i++) {
            for (unsigned j = 0; j < A.col_; j++) {
                if (j != (unsigned)k) {
                    A.m_[i * A.col_ + j] = zero;
                } else {
                    A.m_[i * A.col_ + j] = v[k - k_];
                }
            }
            k++;
        }
    } else {
        k = -k;
 
        for (unsigned j = 0; j < A.col_; j++) {
            for (unsigned i = 0; i < A.row_; i++) {
                if (i != (unsigned)k) {
                    A.m_[i * A.col_ + j] = zero;
                } else {
                    A.m_[i * A.col_ + j] = v[k - k_];
                }
            }
            k++;
        }
    }
}

diagonal_matrix()

RCP< const MatrixExpr > SymEngine::diagonal_matrix

(

const vec_basic &

container

)

Definition at line 67 of file diagonal_matrix.cpp.

{
    if (is_zero_vec(container)) {
        return make_rcp<const ZeroMatrix>(integer(container.size()),
                                          integer(container.size()));
    } else if (is_identity_vec(container)) {
        return make_rcp<const IdentityMatrix>(integer(container.size()));
    } else {
        return make_rcp<const DiagonalMatrix>(container);
    }
}

diagonal_solve()

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

Definition at line 1130 of file dense_matrix.cpp.

{
    SYMENGINE_ASSERT(A.row_ == A.col_);
    SYMENGINE_ASSERT(x.row_ == A.col_ and x.col_ == b.col_);
 
    const unsigned sys = b.col_;
 
    // No checks are done to see if the diagonal entries are zero
    for (unsigned k = 0; k < sys; k++) {
        for (unsigned i = 0; i < A.col_; i++) {
            x.m_[i * sys + k] = div(b.m_[i * sys + k], A.m_[i * A.col_ + i]);
        }
    }
}

diff() [1/2]

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

Definition at line 566 of file dense_matrix.cpp.

{
    SYMENGINE_ASSERT(A.row_ == result.nrows() and A.col_ == result.ncols());
#pragma omp parallel for
    for (unsigned i = 0; i < result.row_; i++) {
        for (unsigned j = 0; j < result.col_; j++) {
            result.m_[i * result.col_ + j]
                = A.m_[i * result.col_ + j]->diff(x, diff_cache);
        }
    }
}

diff() [2/2]

RCP< const Basic > SymEngine::diff	(	const RCP< const Basic > &	arg,
		const RCP< const Symbol > &	x,
		bool	cache
	)

Differentiation w.r.t symbols.

Definition at line 803 of file derivative.cpp.

{
    DiffVisitor v(x, cache);
    return v.apply(arg);
}

diff_mpoly()

template<typename Container , typename Poly >

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

static

Definition at line 142 of file derivative.cpp.

{
    using Dict = typename Container::dict_type;
    using Vec = typename Container::vec_type;
    Dict dict;
 
    if (self.get_vars().find(x) != self.get_vars().end()) {
        auto i = self.get_vars().begin();
        unsigned int index = 0;
        while (!(*i)->__eq__(*x)) {
            i++;
            index++;
        } // find the index of the variable we are differentiating WRT.
        for (auto bucket : self.get_poly().dict_) {
            if (bucket.first[index] != 0) {
                Vec v = bucket.first;
                v[index]--;
                dict.insert({v, bucket.second * bucket.first[index]});
            }
        }
        vec_basic v;
        v.insert(v.begin(), self.get_vars().begin(), self.get_vars().end());
        return Poly::from_dict(v, std::move(dict));
    } else {
        vec_basic vs;
        vs.insert(vs.begin(), self.get_vars().begin(), self.get_vars().end());
        return Poly::from_dict(vs, {{}});
    }
}

diff_upoly()

template<typename Poly , typename Dict >

static RCP< const Basic > SymEngine::diff_upoly ( const Poly &  self, const Symbol &  x  )

inlinestatic

Definition at line 127 of file derivative.cpp.

{
    if (self.get_var()->__eq__(x)) {
        Dict d;
        for (auto it = self.begin(); it != self.end(); ++it) {
            if (it->first != 0)
                d[it->first - 1] = it->second * it->first;
        }
        return Poly::from_dict(self.get_var(), std::move(d));
    } else {
        return Poly::from_dict(self.get_var(), {{}});
    }
}

diff_upolyflint()

template<typename P >

static RCP< const Basic > SymEngine::diff_upolyflint ( const P &  self, const Symbol &  x  )

inlinestatic

Definition at line 117 of file derivative.cpp.

{
    if (self.get_var()->__eq__(x)) {
        return P::from_container(self.get_var(), self.get_poly().derivative());
    } else {
        return P::from_dict(self.get_var(), {{}});
    }
}

digamma()

RCP< const Basic > SymEngine::digamma

(

const RCP< const Basic > &

x

)

Definition at line 3453 of file functions.cpp.

{
    return polygamma(zero, x);
}

dirichlet_eta()

RCP< const Basic > SymEngine::dirichlet_eta

(

const RCP< const Basic > &

s

)

Create a new Dirichlet_eta instance:

Definition at line 2861 of file functions.cpp.

{
    if (is_a_Number(*s) and down_cast<const Number &>(*s).is_one()) {
        return log(i2);
    }
    RCP<const Basic> z = zeta(s);
    if (is_a<Zeta>(*z)) {
        return make_rcp<const Dirichlet_eta>(s);
    } else {
        return mul(sub(one, pow(i2, sub(one, s))), z);
    }
}

div()

RCP< const Basic > SymEngine::div	(	const RCP< const Basic > &	a,
		const RCP< const Basic > &	b
	)

Division.

Definition at line 431 of file mul.cpp.

{
    if (is_number_and_zero(*b)) {
        if (is_number_and_zero(*a)) {
            return Nan;
        } else {
            return ComplexInf;
        }
    }
    return mul(a, pow(b, minus_one));
}

divides()

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

Returns

true if b divides a

Definition at line 161 of file ntheory.cpp.

{
    return mp_divisible_p(a.as_integer_class(), b.as_integer_class()) != 0;
}

divides_upoly() [1/2]

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

Definition at line 25 of file uintpoly.cpp.

{
    if (!(a.get_var()->__eq__(*b.get_var())))
        throw SymEngineException("Error: variables must agree.");
 
    auto a_poly = a.get_poly();
    auto b_poly = b.get_poly();
    if (a_poly.size() == 0)
        return false;
 
    ma