Functions to handle the exchange properties of two or more symbols in a product. More...

Namespaces
	symbols

Classes
class	Algorithm
	Base class for all algorithms, containing generic routines and in particular the logic for index classification. More...

class	tree_less_obj
	Compare two trees by pattern logic, i.e. modulo index names. More...

class	tree_less_modprel_obj

class	tree_equal_obj

class	tree_exact_less_obj
	Compare two trees exactly, i.e. including exact index names. More...

class	tree_exact_less_mod_prel_obj

class	tree_exact_equal_obj

class	tree_exact_equal_mod_prel_obj

class	tree_exact_less_for_indexmap_obj
	Compare for indexmap_t. More...

class	tree_exact_less_no_wildcards_obj
	Compare two trees exactly, treat wildcard names as ordinary names. More...

class	tree_exact_less_no_wildcards_mod_prel_obj

class	Ex_comparator
	A generic tree comparison class which will take into account index contractions and will also keep track of a replacement list for all types of cadabra wildcards. More...

class	Ex_is_equivalent
	Basic comparison operator for tree iterators, so we can use them as keys in maps. More...

class	Ex_is_less

class	DisplayBase
	Base class for all display classes. More...

class	DisplayMMA
	Class to display expressions in a format that Mathematica can parse. More...

class	DisplaySympy
	Class to display expressions in a format that Sympy can parse. More...

class	DisplayTerminal
	Class to display expressions to the terminal. More...

class	DisplayTeX
	Class to handle display of expressions using LaTeX notation. More...

class	exchange

class	index_iterator
	An iterator which iterates over indices even if they are at lower levels, i.e. More...

class	Kernel

class	Parser

class	pattern

class	keyval_t
	Arguments to properties get parsed into a keyval_t structure. More...

class	property
	Base class for all properties, handling argument parsing and defining the interface. More...

class	labelled_property

class	list_property
	Something cannot be both a list property and a normal property at the same time, so we can safely inherit without virtual. More...

class	Inherit
	If a property X derives from Inherit<Y>, and get<Y> is called on an object which has an X property (but no Y property), then the get<Y> will look at the non-index child of the object to see if that has a Y property. More...

class	PropertyInherit
	PropertyInherit is like Inherit<T> for all properties. More...

class	Properties
	Class holding a collection of properties attached to expressions. More...

class	str_node
	Elementary building block for a mathematical expression. More...

class	Ex
	Basic storage class for symbolic mathemematical expressions. More...

class	nset_it_less
	Compare two nset iterators by comparing the strings to which they point. More...

class	TerminalStream

class	canonicalise
	Canonicalise the index structure of a tensorial expression. More...

class	collect_components
	Collect terms inside a sum, merging their substitution rules. More...

class	collect_factors
	Collect symbolically equal factors in a product. More...

class	collect_terms
	Collect symbolically equal terms in a sum. More...

class	combine

class	complete
	Complete a set of coordinate rules so that they also cover related tensors. More...

class	decompose_product
	Decompose a product of tensors by applying Young projectors. More...

class	distribute
	Distribute factors over a sum, that is, \( (A+B) C \rightarrow A C + B C \). More...

class	drop_keep_weight

class	drop_weight

class	keep_weight

class	einsteinify

class	eliminate_kronecker

class	eliminate_converter

class	eliminate_metric

class	epsilon_to_delta

class	evaluate

class	expand

class	expand_delta

class	expand_diracbar

class	expand_power

class	factor_in

class	factor_out

class	fierz

class	flatten_product

class	flatten_sum

class	indexsort

class	integrate_by_parts
	Integrate by parts away from the indicated derivative object. More...

class	join_gamma

class	keep_terms

class	lr_tensor

class	map_mma
	Functionality to act with Mathematica on all scalar parts of an expression, and keep the result in-place. More...

class	map_sympy
	Functionality to act with Sympy on all scalar parts of an expression, and keep the result in-place. More...

class	order

class	product_rule

class	reduce_delta

class	rename_dummies

class	replace_match

class	rewrite_indices

class	sort_product

class	sort_spinors

class	sort_sum

class	split_gamma

class	split_index

class	substitute
	Generic substitution algorithm. More...

class	sym

class	tab_basics

class	take_match

class	unwrap

class	vary
	Generic variational derivative algorithm. More...

class	young_project

class	young_project_product

class	young_project_tensor

class	Accent
	Turns a symbol into an accent. More...

class	AntiCommuting

class	AntiSymmetric

class	Commuting

class	CommutingAsProduct

class	CommutingAsSum

class	CommutingBehaviour

class	Coordinate

class	DAntiSymmetric

class	Depends

class	DependsBase

class	DependsInherit

class	Derivative

class	Diagonal

class	DifferentialForm

class	DifferentialFormBase

class	DiracBar

class	Distributable

class	EpsilonTensor

class	ExteriorDerivative

class	FilledTableau

class	GammaMatrix

class	GammaTraceless

class	ImaginaryI

class	ImplicitIndex

class	IndexInherit

class	Indices

class	Integer
	Property indicating that a symbolic object always takes integer values. More...

class	InverseMetric

class	KroneckerDelta

class	LaTeXForm

class	Matrix

class	Metric

class	NonCommuting

class	NumericalFlat
	Property indicating that an operator is numerically flat, so that numerical factors in the argument can be taken outside. More...

class	PartialDerivative

class	RiemannTensor

class	SatisfiesBianchi

class	SelfAntiCommuting

class	SelfCommuting

class	SelfCommutingBehaviour

class	SelfNonCommuting

class	SortOrder

class	Spinor

class	Symbol

class	Symmetric

class	Tableau

class	TableauBase

class	TableauSymmetry

class	Traceless

class	Weight

class	WeightBase

class	WeightInherit

class	WeylTensor

class	ActionBase
	All actions derive from the ActionBase object, which defines the interface they need to implement. More...

class	ActionAddCell
	Add a cell to the notebook. More...

class	ActionPositionCursor
	Position the cursor relative to the indicated cell. More...

class	ActionSetRunStatus
	Update the running status of the indicated cell. More...

class	ActionRemoveCell
	Remove a cell and all its child cells from the document. More...

class	ActionSplitCell
	Split a cell into two separate cells, at the point of the cursor. More...

class	ActionInsertText
	Add a text string (can be just a single character) at the point of the cursor. More...

class	ActionEraseText
	Remove a text string starting at the indicated position, and with the indicated length, from the indicated cell. More...

class	ComputeThread
	Base class which talks to the server and sends Action objects back to the DocumentThread. More...

class	DataCell
	DataCells are the basic building blocks for a document. More...

class	DocumentThread
	A base class with all the logic to manipulate a Cadabra notebook document. More...

class	GUIBase
	Abstract base class with methods that need to be implemented by any GUI. More...

class	TeXEngine
	TeXEngine is used to convert LaTeX strings into PNG images. More...

class	CodeInput
	A text cell editor widget with support for editing Python and LaTeX. More...

class	ImageView
	An image viewing widget. More...

class	NotebookCanvas

class	NotebookWindow
	Each notebook has one main window which controls it. More...

class	TeXView
	TeXView is a widget which knows how to turn a string into a LaTeX-rendered image and display that. More...

class	VisualCell
	Structure holding a pointer to one of the possible GUI widgets that can appear in a document. More...

Typedefs
typedef void(*	dispatcher_t )(const Kernel &k, Ex &, Ex::iterator &it)

typedef mpq_class	multiplier_t

typedef std::set< std::string >	nset_t

typedef std::set< multiplier_t >	rset_t

typedef uintptr_t	hashval_t

typedef tree< DataCell >	DTree

Functions
std::string	escape_quotes (const std::string &)

std::string	cdb2python (const std::string &)

std::string	convert_line (const std::string &, std::string &lhs, std::string &rhs, std::string &indent)

void	cleanup_dispatch (const Kernel &k, Ex &, Ex::iterator &it)
	Central cleanup dispatch routine, which calls the other cleanup functions defined later. More...

void	check_index_consistency (const Kernel &k, Ex &tr, Ex::iterator it)
	Generic tool to check for index inconsistencies independent of running any algorithm. More...

bool	cleanup_productlike (const Kernel &k, Ex &, Ex::iterator &it)
	Individual node cleanup routines. More...

bool	cleanup_sumlike (const Kernel &k, Ex &tr, Ex::iterator &it)

bool	push_down_multiplier (const Kernel &k, Ex &tr, Ex::iterator it)
	Given a node with a non-unit multiplier, push this multiplier down the tree if the node is not allowed to have a non-unit multiplier. More...

bool	cleanup_components (const Kernel &k, Ex &tr, Ex::iterator &it)

bool	cleanup_partialderivative (const Kernel &k, Ex &tr, Ex::iterator &it)

bool	cleanup_derivative (const Kernel &k, Ex &tr, Ex::iterator &it)

bool	cleanup_numericalflat (const Kernel &k, Ex &tr, Ex::iterator &it)

bool	cleanup_diagonal (const Kernel &k, Ex &tr, Ex::iterator &it)

bool	cleanup_kronecker (const Kernel &k, Ex &tr, Ex::iterator &it)

bool	cleanup_exterior_derivative (const Kernel &k, Ex &tr, Ex::iterator &it)

void	cleanup_dispatch_deep (const Kernel &k, Ex &, dispatcher_t disp=&cleanup_dispatch)
	More general cleanup of an entire tree. More...

void	cleanup_dispatch_deep (const Kernel &k, Ex &tr, Ex::iterator &top, dispatcher_t dispatch)

int	subtree_compare (const Properties *, Ex::iterator one, Ex::iterator two, int mod_prel=-2, bool checksets=true, int compare_multiplier=-2, bool literal_wildcards=false)
	Basic building block subtree comparison function for tensors without dummy indices, which determines whether two tensor subtrees are equal up to the names of indices. More...

bool	tree_less (const Properties *, const Ex &one, const Ex &two, int mod_prel=-2, bool checksets=true, int compare_multiplier=-2)
	Various comparison functions, some exact, some with pattern logic. More...

bool	tree_equal (const Properties *properties, const Ex &one, const Ex &two, int mod_prel, bool checksets, int compare_multiplier)

bool	tree_exact_less (const Properties *properties, const Ex &one, const Ex &two, int mod_prel, bool checksets, int compare_multiplier, bool literal_wildcards)

bool	tree_exact_equal (const Properties *properties, const Ex &one, const Ex &two, int mod_prel, bool checksets, int compare_multiplier, bool literal_wildcards)

bool	subtree_less (const Properties *properties, Ex::iterator one, Ex::iterator two, int mod_prel, bool checksets, int compare_multiplier)

bool	subtree_equal (const Properties *properties, Ex::iterator one, Ex::iterator two, int mod_prel, bool checksets, int compare_multiplier)

bool	subtree_exact_less (const Properties *properties, Ex::iterator one, Ex::iterator two, int mod_prel, bool checksets, int compare_multiplier, bool literal_wildcards)

bool	subtree_exact_equal (const Properties *properties, Ex::iterator one, Ex::iterator two, int mod_prel, bool checksets, int compare_multiplier, bool literal_wildcards)

const char *	unichar (kunichar c)

bool	operator< (const exchange::tensor_type_t &one, const exchange::tensor_type_t &two)

void	do_list (const Ex &tr, Ex::iterator it, std::function< bool(Ex::iterator)> f)
	Apply a function on every element of a list, or if the iterator 'it' does not point to a list, only on that single element. More...

int	list_size (const Ex &tr, Ex::iterator it)
	For lists as defined above for 'do_list', return their size (in case you really need to know the size before iterating over the elements). More...

Ex::iterator	do_subtree (const Ex &tr, Ex::iterator it, std::function< Ex::iterator(Ex::iterator)> f)
	Apply a function on every node in the tree at and below the given node, depth-first. More...

Ex::iterator	find_in_subtree (const Ex &tr, Ex::iterator it, std::function< bool(Ex::iterator)> f, bool including_head=true)
	Returns an iterator to the first element for which 'f' returns 'true', or 'tr.end()'. More...

Ex::iterator	find_in_list (const Ex &tr, Ex::iterator it, std::function< Ex::iterator(Ex::iterator)> f)
	Returns an iterator to the first element for which 'f' does not return tr.end(). More...

Ex	make_list (Ex el)
	Ensure that the tree is a list, even if it contains only a single element. More...

void	pre_clean_dispatch (const Kernel &kernel, Ex &ex, Ex::iterator &it)

void	pre_clean_dispatch_deep (const Kernel &k, Ex &tr)

void	cleanup_updown (const Kernel &k, Ex &, Ex::iterator &it)
	Cleanup for individual node types. More...

void	cleanup_rational (const Kernel &k, Ex &tr, Ex::iterator &st)

void	cleanup_frac (const Kernel &k, Ex &tr, Ex::iterator &st)

void	cleanup_sub (const Kernel &k, Ex &tr, Ex::iterator &it)

void	cleanup_indexbracket (const Kernel &k, Ex &, Ex::iterator &it)
	Convert parser output which indicates an indexbracket to an actual indexbracket node. More...

long	to_long (multiplier_t mul)

std::string	to_string (long num)

void	multiply (rset_t::iterator &, multiplier_t)
	Helper functions for manipulation of multipliers. More...

void	add (rset_t::iterator &num, multiplier_t fac)

void	zero (rset_t::iterator &num)

void	one (rset_t::iterator &num)

void	flip_sign (rset_t::iterator &num)

void	half (rset_t::iterator &num)

template<typename T >
bool	is_in (const T &val, const std::initializer_list< T > &list)

std::string	JSON_serialise (const DTree &)
	Serialise a document into .cj format, which is a JSON version of the document tree. More...

void	JSON_recurse (const DTree &, DTree::iterator, Json::Value &)

void	JSON_deserialise (const std::string &, DTree &)
	Load a document from .cj format, i.e. the inverse of the above. More...

void	JSON_in_recurse (DTree &doc, DTree::iterator loc, const Json::Value &cells)

std::string	export_as_HTML (const DTree &doc, bool for_embedding=false, std::string title="")
	Export a document to a single self-contained HTML file containing inline CSS. More...

void	HTML_recurse (const DTree &doc, DTree::iterator it, std::ostringstream &str, const std::string &preamble_string, bool for_embedding=false, std::string title="")

std::string	latex_to_html (const std::string &)
	Convert various LaTeX constructions to HTML-with-Mathjax, e.g. More...

std::string	export_as_LaTeX (const DTree &doc)
	Export a document to a single self-contained LaTeX file. More...

void	LaTeX_recurse (const DTree &doc, DTree::iterator it, std::ostringstream &str, const std::string &preamble_string)

std::string	export_as_python (const DTree &doc)
	Export a document to a python-like file (converting text cells to comments and python cells to python code, dropping output cells). More...

void	python_recurse (const DTree &doc, DTree::iterator it, std::ostringstream &str)

Variables
nset_t	name_set

rset_t	rat_set

Detailed Description

Functions to handle the exchange properties of two or more symbols in a product.

Evaluate a tensorial expression to components, performing all dummy index sums.

Handle the entire preclean stage, which turns a parsed expression into an expression which satisfies the Cadabra conventions.

Parser module, which takes the string output of the preprocessor.hh module and turns it into an Ex expression tree.

Cadabra kernel that keeps all state information that needs to be passed around to algorithms and properties.

This module is only concerned with the exchange properties of tensors as a whole, not with index permutation symmetries (which are handled in the canonicalise class of algebra.cc).

At the moment only stores property information, but could also store global settings and the like at some later stage.

The output of preprocessor.hh is assumed to be valid and consistent, so the code here is rather simple.

This does not involve the property system.

All numerical multipliers in a product on the product node, no multiplier on a sum node.
Any '\frac' nodes with a purely numerical denominator should be rewritten as a rational multiplier for the numerator node.
Any \sub nodes get converted to \sum nodes.

See tests/components.cdb for basic samples.

Components nodes have the following structure:

_{m} // index names/types _{n} // last child // list of index values r t [value] // value of tensor for above values of indices ... ...

ex:= A_{m n} ( A_{m n} + B_{m n} ); crds:= m -> { t, r, , }; vals:= { A_{t t} -> r, A_{r r} -> r**2, A_{t } -> t, B_{t t} -> 1 }; evaluate(ex, crds, vals); tst:= r * ( r + 1 ) + r**2 * r**2 + t*t - @(ex);

The algorithm performs the following steps. First, all free and dummy indices are classified using members of Algorithm (maybe later?). For all indices, the 'crds' argument to the algorithm is scanned for a
```
m -> { a,b,c }
```

type pattern.

Do a dept-first scan until the first sum or product node.

In a sum node, all terms must have the same index structure, so we can now make a map from the subtree pattern to all possible index values. For each such index value set, lookup if there is a replacement pattern, if not replace by zero. This map can be reused later for equal sub-expressions (here it is important that a normal tensor expression can be used as a pattern immediately, though I would search both on explicit iterator (for things that we have just seen) and on pattern (for things that occur again later in the tree)).

In a product node, find all dummies and free indices. Create a set of all index value sets, e.g.

{m, n, p} -> { {t, t, t}, {r,t,t}, {t,r,t}, ... }

For each such index value set, lookup replacement rules.

KEY: quick way to lookup, for a given set of index values on a (found) pattern/pattern pointed to by iterator, whether and what is the value of the pattern.

Typedef Documentation

typedef void(* cadabra::dispatcher_t)(const Kernel &k, Ex &, Ex::iterator &it)

typedef tree<DataCell> cadabra::DTree

typedef uintptr_t cadabra::hashval_t

typedef mpq_class cadabra::multiplier_t

typedef std::set<std::string> cadabra::nset_t

typedef std::set<multiplier_t> cadabra::rset_t

Function Documentation

void cadabra::add	(	rset_t::iterator &	num,
		multiplier_t	fac
	)

std::string cadabra::cdb2python ( const std::string & blk )

void cadabra::check_index_consistency	(	const Kernel &	k,
		Ex &	tr,
		Ex::iterator	it
	)

Generic tool to check for index inconsistencies independent of running any algorithm.

bool cadabra::cleanup_components	(	const Kernel &	k,
		Ex &	tr,
		Ex::iterator &	it
	)

bool cadabra::cleanup_derivative	(	const Kernel &	k,
		Ex &	tr,
		Ex::iterator &	it
	)

bool cadabra::cleanup_diagonal	(	const Kernel &	k,
		Ex &	tr,
		Ex::iterator &	it
	)

void cadabra::cleanup_dispatch_deep	(	const Kernel &	k,
		Ex &	tr,
		Ex::iterator &	top,
		dispatcher_t	dispatch
	)

bool cadabra::cleanup_exterior_derivative	(	const Kernel &	k,
		Ex &	tr,
		Ex::iterator &	it
	)

void cadabra::cleanup_frac	(	const Kernel &	k,
		Ex &	tr,
		Ex::iterator &	st
	)

void cadabra::cleanup_indexbracket	(	const Kernel &	k,
		Ex &	,
		Ex::iterator &	it
	)

Convert parser output which indicates an indexbracket to an actual indexbracket node.

bool cadabra::cleanup_kronecker	(	const Kernel &	k,
		Ex &	tr,
		Ex::iterator &	it
	)

bool cadabra::cleanup_numericalflat	(	const Kernel &	k,
		Ex &	tr,
		Ex::iterator &	it
	)

bool cadabra::cleanup_partialderivative	(	const Kernel &	k,
		Ex &	tr,
		Ex::iterator &	it
	)

bool cadabra::cleanup_productlike	(	const Kernel &	k,
		Ex &	,
		Ex::iterator &	it
	)

Individual node cleanup routines.

Do not call these yourself.

Once more, these algorithms clean up the tree at the current node and the first layer of child nodes, but do NOT descend deeper down the tree, except when that is necessary to ensure that the tree remains consistent. As with any algorithms, the iterator pointing to the starting node may be changed, but these functions are not allowed to modify anything except the node and nodes below (in particular, they will leave sibling nodes untouched).

void cadabra::cleanup_rational	(	const Kernel &	k,
		Ex &	tr,
		Ex::iterator &	st
	)

void cadabra::cleanup_sub	(	const Kernel &	k,
		Ex &	tr,
		Ex::iterator &	it
	)

bool cadabra::cleanup_sumlike	(	const Kernel &	k,
		Ex &	tr,
		Ex::iterator &	it
	)

void cadabra::cleanup_updown	(	const Kernel &	k,
		Ex &	,
		Ex::iterator &	it
	)

Cleanup for individual node types.

These are not needed during any later stages of the manipulation of an expression (and are hence defined here, not in 'Cleanup.hh').

std::string cadabra::convert_line	(	const std::string &	line,
		std::string &	lhs,
		std::string &	rhs,
		std::string &	indent
	)

std::string cadabra::escape_quotes ( const std::string & line )

std::string cadabra::export_as_HTML	(	const DTree &	doc,
		bool	for_embedding = `false`,
		std::string	title = `""`
	)

Export a document to a single self-contained HTML file containing inline CSS.

std::string cadabra::export_as_LaTeX ( const DTree & doc )

Export a document to a single self-contained LaTeX file.

std::string cadabra::export_as_python ( const DTree & doc )

Export a document to a python-like file (converting text cells to comments and python cells to python code, dropping output cells).

void cadabra::flip_sign ( rset_t::iterator & num )

void cadabra::half ( rset_t::iterator & num )

void cadabra::HTML_recurse	(	const DTree &	doc,
		DTree::iterator	it,
		std::ostringstream &	str,
		const std::string &	preamble_string,
		bool	for_embedding = `false`,
		std::string	title = `""`
	)

template<typename T >

bool cadabra::is_in	(	const T &	val,
		const std::initializer_list< T > &	list
	)

void cadabra::JSON_deserialise	(	const std::string &	cj,
		DTree &	doc
	)

Load a document from .cj format, i.e. the inverse of the above.

void cadabra::JSON_in_recurse	(	DTree &	doc,
		DTree::iterator	loc,
		const Json::Value &	cells
	)

void cadabra::JSON_recurse	(	const DTree &	doc,
		DTree::iterator	it,
		Json::Value &	json
	)

std::string cadabra::JSON_serialise ( const DTree & doc )

Serialise a document into .cj format, which is a JSON version of the document tree.

void cadabra::LaTeX_recurse	(	const DTree &	doc,
		DTree::iterator	it,
		std::ostringstream &	str,
		const std::string &	preamble_string
	)

std::string cadabra::latex_to_html ( const std::string & str )

Convert various LaTeX constructions to HTML-with-Mathjax, e.g.

\section{...}, \begin{verbatim}...\end{verbatim}, \verb.

void cadabra::one ( rset_t::iterator & num )

bool cadabra::operator<	(	const exchange::tensor_type_t &	one,
		const exchange::tensor_type_t &	two
	)

void cadabra::pre_clean_dispatch	(	const Kernel &	kernel,
		Ex &	ex,
		Ex::iterator &	it
	)

void cadabra::pre_clean_dispatch_deep	(	const Kernel &	k,
		Ex &	tr
	)

bool cadabra::push_down_multiplier	(	const Kernel &	k,
		Ex &	tr,
		Ex::iterator	it
	)

Given a node with a non-unit multiplier, push this multiplier down the tree if the node is not allowed to have a non-unit multiplier.

This is a recursive procedure as the node onto which the multiplier gets pushed may itself not allow for a non-unit multiplier. Note that some nodes disallow non-unit multipliers on their children, but that should be handled individually (see cleanup of product nodes for an example).

void cadabra::python_recurse	(	const DTree &	doc,
		DTree::iterator	it,
		std::ostringstream &	str
	)

bool cadabra::subtree_equal	(	const Properties *	properties,
		Ex::iterator	one,
		Ex::iterator	two,
		int	mod_prel,
		bool	checksets,
		int	compare_multiplier
	)

bool cadabra::subtree_exact_equal	(	const Properties *	properties,
		Ex::iterator	one,
		Ex::iterator	two,
		int	mod_prel,
		bool	checksets,
		int	compare_multiplier,
		bool	literal_wildcards
	)

bool cadabra::subtree_exact_less	(	const Properties *	properties,
		Ex::iterator	one,
		Ex::iterator	two,
		int	mod_prel,
		bool	checksets,
		int	compare_multiplier,
		bool	literal_wildcards
	)

bool cadabra::subtree_less	(	const Properties *	properties,
		Ex::iterator	one,
		Ex::iterator	two,
		int	mod_prel,
		bool	checksets,
		int	compare_multiplier
	)

long cadabra::to_long ( multiplier_t mul )

std::string cadabra::to_string ( long num )

bool cadabra::tree_equal	(	const Properties *	properties,
		const Ex &	one,
		const Ex &	two,
		int	mod_prel,
		bool	checksets,
		int	compare_multiplier
	)

bool cadabra::tree_exact_equal	(	const Properties *	properties,
		const Ex &	one,
		const Ex &	two,
		int	mod_prel,
		bool	checksets,
		int	compare_multiplier,
		bool	literal_wildcards
	)

bool cadabra::tree_exact_less	(	const Properties *	properties,
		const Ex &	one,
		const Ex &	two,
		int	mod_prel,
		bool	checksets,
		int	compare_multiplier,
		bool	literal_wildcards
	)

bool cadabra::tree_less	(	const Properties *	properties,
		const Ex &	one,
		const Ex &	two,
		int	mod_prel,
		bool	checksets,
		int	compare_multiplier
	)

Various comparison functions, some exact, some with pattern logic.

const char * cadabra::unichar ( kunichar c )

void cadabra::zero ( rset_t::iterator & num )

Variable Documentation

nset_t cadabra::name_set

rset_t cadabra::rat_set

Namespaces

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

Function Documentation

Variable Documentation