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

Namespaces
	symbols

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

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

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

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

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

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

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

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

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

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

class	AntiCommuting

class	AntiSymmetric

class	BoundProperty

class	BoundPropertyBase

class	CadabraJupyter
	A Jupyter kernel for Cadabra, which provides the Cadabra pre-processor to enable input as in the Gtk notebook frontend. More...

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

class	ChooseColoursDialog

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

class	collect_components
	Collect `\components` 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	Commuting

class	CommutingAsProduct

class	CommutingAsSum

class	CommutingBehaviour

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

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

class	Console

class	Coordinate

class	DAntiSymmetric

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

class	decompose

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

class	Depends

class	DependsBase

class	DependsInherit

class	Derivative

class	Determinant

class	Diagonal

class	DifferentialForm

class	DifferentialFormBase

class	DiracBar

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	Distributable

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

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

class	drop_keep_weight

class	drop_weight

class	einsteinify

class	eliminate_converter

class	eliminate_kronecker

class	eliminate_metric

class	eliminate_vielbein

class	epsilon_to_delta

class	EpsilonTensor

class	evaluate

class	Evaluator

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

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_hasher

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	exchange

class	expand

class	expand_delta

class	expand_diracbar

class	expand_power

class	explicit_indices

class	ExteriorDerivative

class	factor_in

class	factor_out

class	fierz

class	FilledTableau

class	flatten_product

class	flatten_sum

class	GammaMatrix

class	GammaTraceless

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

class	ImageView
	An image viewing widget. More...

class	ImaginaryI

class	ImplicitIndex

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

class	IndexClassifier

class	IndexInherit

class	indexsort

class	Indices

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	Integer
	Property indicating that a symbolic object always takes integer values. More...

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

class	InverseMetric

class	InverseVielbein

class	join_gamma

class	keep_terms

class	keep_weight

class	Kernel

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

class	KroneckerDelta

class	labelled_property

class	LaTeXForm

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	lower_free_indices

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	Matrix

class	Metric

class	NonCommuting

class	NotebookCanvas

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

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

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

class	order

class	Parser

class	PartialDerivative

class	pattern

class	product_rule

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

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

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

class	reduce_delta

class	rename_dummies

class	replace_match

class	rewrite_indices

class	RiemannTensor

class	SatisfiesBianchi

class	SelfAntiCommuting

class	SelfCommuting

class	SelfCommutingBehaviour

class	SelfNonCommuting

class	simplify
	General purpose brute force scalar simplification algorithm. More...

class	sort_product

class	sort_spinors

class	sort_sum

class	SortOrder

class	Spinor

class	split_gamma

class	split_index

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

class	substitute
	Generic substitution algorithm. More...

class	sym

class	Symbol

class	Symmetric

class	tab_basics

class	tabdimension

class	Tableau

class	TableauBase

class	TableauSymmetry

class	take_match

class	TerminalStream

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

class	TextViewProxy

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

class	Trace

class	Traceless

class	tree_equal_obj

class	tree_exact_equal_mod_prel_obj

class	tree_exact_equal_obj

class	tree_exact_less_for_indexmap_obj
	Compare for indexmap_t. More...

class	tree_exact_less_mod_prel_obj

class	tree_exact_less_no_wildcards_mod_prel_obj

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

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

class	tree_less_modprel_obj

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

class	untrace

class	unwrap

class	unzoom

class	vary
	Generic variational derivative algorithm. More...

class	Vielbein

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

class	Weight

class	WeightBase

class	WeightInherit

class	WeylTensor

class	young_project

class	young_project_product

class	young_project_tensor

class	young_reduce

class	zoom

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

typedef tree< DataCell >	DTree

using	flags_base_t = std::underlying_type_t< HashFlags >

typedef mpq_class	multiplier_t

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

typedef std::set< multiplier_t >	rset_t

typedef uintptr_t	hashval_t

using	Ex_ptr = std::shared_ptr< Ex >

using	tab_t = TableauBase::tab_t

Enumerations
enum	HashFlags : unsigned int { HASH_DEFAULT = 0x0, HASH_IGNORE_TOP_MULTIPLIER = 0x1, HASH_IGNORE_MULTIPLIER = 0x2, HASH_IGNORE_PRODUCT_ORDER = 0x4, HASH_IGNORE_SUM_ORDER = 0x8, HASH_IGNORE_INDEX_ORDER = 0x10, HASH_IGNORE_PARENT_REL = 0x20, HASH_IGNORE_BRACKET_TYPE = 0x40, HASH_IGNORE_CHILDREN = 0x80, HASH_IGNORE_NAMES = 0x100, HASH_IGNORE_INDICES = 0x200, HASH_IGNORE_CHILD_ORDER = 0x400 }

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

std::string	cdb2python (const std::string &, bool display)
	Convert a block of Cadabra notation into pure Python. More...

std::string	convert_line (const std::string &, std::string &lhs, std::string &rhs, std::string &op, std::string &indent, bool display)
	As above, but for a single line; for private use only. More...

std::string	cnb2python (const std::string &, bool display)
	Convert a Cadabra notebook file to pure Python. More...

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_powlike (const Kernel &k, Ex &, Ex::iterator &it)
	Individual node cleanup routines. More...

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

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 &, Ex &tr, Ex::iterator &it)

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

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

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

bool	cleanup_kronecker (const Kernel &, 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 &, 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)

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, bool strip_code=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, bool strip_code=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, const std::string &image_file_base)
	Export a document to a single self-contained LaTeX file, with the exception of images which get saved as separate numbered files. More...

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

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)

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

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

HashFlags	operator~ (HashFlags flags)

HashFlags	operator\| (HashFlags lhs, HashFlags rhs)

HashFlags	operator& (HashFlags lhs, HashFlags rhs)

HashFlags &	operator\|= (HashFlags &lhs, HashFlags rhs)

HashFlags &	operator&= (HashFlags &lhs, HashFlags rhs)

Ex_hasher::result_t	hash_ex (Ex::iterator it, HashFlags flags)

bool	hash_compare (Ex::iterator lhs, Ex::iterator rhs, HashFlags flags)

HashFlags	operator& (HashFlags lhs, HashFlags rhs)

HashFlags &	operator&= (HashFlags &lhs, HashFlags rhs)

std::string	install_prefix ()
	Return an absolute path to the installation path. 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 &, Ex &, Ex::iterator &st)

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

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

void	cleanup_sub (const Kernel &, 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...

std::string	replace_all (std::string const &original, std::string const &from, std::string const &to)
	Replace all occurrances of 'from' with 'to', return result (does not replace in-place). 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)

void	init_algorithms (py::module &m)

template<class Algo >
Ex_ptr	apply_algo_base (Algo &algo, Ex_ptr ex, bool deep, bool repeat, unsigned int depth, bool pre_order=false)
	Generic internal entry point for the Python side to execute a C++ algorithm. More...

template<class Algo >
Ex_ptr	apply_algo (Ex_ptr ex, bool deep, bool repeat, unsigned int depth)

template<class Algo , typename Arg1 >
Ex_ptr	apply_algo (Ex_ptr ex, Arg1 arg1, bool deep, bool repeat, unsigned int depth)

template<class Algo , typename Arg1 , typename Arg2 >
Ex_ptr	apply_algo (Ex_ptr ex, Arg1 arg1, Arg2 arg2, bool deep, bool repeat, unsigned int depth)

template<class Algo , typename Arg1 , typename Arg2 , typename Arg3 >
Ex_ptr	apply_algo (Ex_ptr ex, Arg1 arg1, Arg2 arg2, Arg3 arg3, bool deep, bool repeat, unsigned int depth)

template<class Algo , typename... Args, typename... PyArgs>
void	def_algo (pybind11::module &m, const char *name, bool deep, bool repeat, unsigned int depth, PyArgs... pyargs)
	Method to declare a Python function with variable number of arguments, and make that call a C++ algorithm as specified in the Algo template parameter. More...

template<class Algo >
Ex_ptr	apply_algo_preorder (Ex_ptr ex, bool deep, bool repeat, unsigned int depth)

template<class Algo , typename Arg1 >
Ex_ptr	apply_algo_preorder (Ex_ptr ex, Arg1 arg1, bool deep, bool repeat, unsigned int depth)

template<class Algo , typename Arg1 , typename Arg2 >
Ex_ptr	apply_algo_preorder (Ex_ptr ex, Arg1 arg1, Arg2 arg2, bool deep, bool repeat, unsigned int depth)

template<class Algo , typename... Args, typename... PyArgs>
void	def_algo_preorder (pybind11::module &m, const char *name, bool deep, bool repeat, unsigned int depth, PyArgs... pyargs)
	Method to declare a Python function with variable number of arguments, and make that call a C++ algorithm as specified in the Algo template parameter. More...

void	init_algorithms (pybind11::module &m)

bool	Ex_compare (Ex_ptr, Ex_ptr)
	Comparison operator for Ex objects in Python. More...

bool	Ex_compare (Ex_ptr one, int other)

Ex_ptr	Ex_add (const Ex_ptr ex1, const ExNode ex2)
	Add two expressions, adding a top-level node if required. More...

Ex_ptr	Ex_add (const Ex_ptr ex1, const Ex_ptr ex2)

Ex_ptr	Ex_add (const Ex_ptr ex1, const Ex_ptr ex2, Ex::iterator top2)

Ex_ptr	Ex_mul (const Ex_ptr ex1, const Ex_ptr ex2)
	Multiply two expressions, adding a top-level node if required. More...

Ex_ptr	Ex_mul (const Ex_ptr ex1, const Ex_ptr ex2, Ex::iterator top2)

Ex_ptr	Ex_sub (const Ex_ptr ex1, const ExNode ex2)
	Subtract two expressions, adding a top-level node if required. More...

Ex_ptr	Ex_sub (const Ex_ptr ex1, const Ex_ptr ex2)

Ex_ptr	Ex_sub (const Ex_ptr ex1, const Ex_ptr ex2, Ex::iterator top2)

Ex_ptr	fetch_from_python (const std::string &nm)
	Fetch an Ex object from the Python side using its Python identifier. More...

Ex_ptr	fetch_from_python (const std::string &nm, pybind11::object scope)

std::string	Ex_as_str (Ex_ptr)
	Generate the Python str() and repr() representation of the Ex object. More...

std::string	Ex_as_repr (Ex_ptr ex)

std::string	Ex_as_latex (Ex_ptr)
	The Python 'print' function always calls the 'str' member on objects to be printed. More...

pybind11::object	Ex_as_sympy (Ex_ptr)
	Outputs a Cadabra 'Ex' as a Sympy expression. More...

std::string	Ex_as_sympy_string (Ex_ptr)
	Similar to Ex_to_Sympy, but only producing a string which can be parsed by Sympy, instead of a full-fledged Sympy expression. More...

std::string	Ex_as_input (Ex_ptr ex)

std::string	Ex_as_MMA (Ex_ptr ex, bool use_unicode)

std::string	print_tree (Ex *ex)

Ex	lhs (Ex_ptr ex)

Ex	rhs (Ex_ptr ex)

Ex	Ex_getslice (Ex_ptr ex, pybind11::slice slice)

Ex	Ex_getitem (Ex &ex, int index)

void	Ex_setitem (Ex_ptr ex, int index, Ex val)

void	Ex_setitem_iterator (Ex_ptr ex, ExNode en, Ex_ptr val)

size_t	Ex_len (Ex_ptr ex)

std::string	Ex_head (Ex_ptr ex)

pybind11::object	Ex_get_mult (Ex_ptr ex)

pybind11::list	terms (Ex_ptr ex)

std::shared_ptr< sympy::SympyBridge >	SympyBridge_init (std::shared_ptr< Ex > ex)

Ex_ptr	Ex_from_string (const std::string &ex_, bool, Kernel *kernel)

Ex_ptr	Ex_from_int (int num, bool)

void	call_post_process (Kernel &kernel, Ex_ptr ex)

Ex_ptr	map_sympy_wrapper (Ex_ptr ex, std::string head, pybind11::args args)

void	init_ex (py::module &m)

std::string	Ex_as_tree (Ex *ex)

void	init_ex (pybind11::module &m)

py::object	get_locals ()

py::object	get_globals ()

bool	scope_has (const py::dict &dict, const std::string &obj)

std::string	read_manual (const char category, const char name)

bool	scope_has (const pybind11::dict &dict, const std::string &obj)

Kernel *	create_scope ()
	Setup of kernels in current scope, callable from Python. More...

Kernel *	create_scope_from_global ()

Kernel *	create_empty_scope ()

Kernel *	get_kernel_from_scope ()
	Get a pointer to the currently visible kernel. More...

void	inject_defaults (Kernel *)
	Inject properties directly into the Kernel, even if the kernel is not yet on the Python stack (needed when we create a new local scope: in this case we create the kernel and pass it back to be turned into local cdbkernel by Python, but we want to populate the kernel with defaults before we hand it back). More...

void	init_kernel (pybind11::module &m)

std::string	init_ipython ()

	PYBIND11_MODULE (cadabra2, m)

void	compile_package (const std::string &in_name, const std::string &out_name)
	Convert a Cadabra notebook file to a python package which can be imported using standard 'import' notation. More...

void	init_packages (pybind11::module &m)

py::list	ProgressMonitor_totals_helper (ProgressMonitor &self)

ProgressMonitor *	get_progress_monitor ()

void	init_progress_monitor (py::module &m)

void	init_progress_monitor (pybind11::module &m)

template<typename BoundPropT >
BoundPropT::py_type	def_abstract_prop (pybind11::module &m, const std::string &name)

template<typename BoundPropT >
BoundPropT::py_type	def_prop (pybind11::module &m)

pybind11::list	list_properties ()

void	init_properties (py::module &m)

template<typename PropT >
std::string	get_name ()

template<typename BoundPropT >
BoundPropT::py_type	def_abstract_prop (pybind11::module &m)

void	init_properties (pybind11::module &m)

void	init_stopwatch (py::module &m)

void	init_stopwatch (pybind11::module &m)

std::string	tab_str (const tab_t &tab)

void	init_tableau (pybind11::module &m)

std::string	capitalize_first (std::string in)

Variables
nset_t	name_set

rset_t	rat_set

bool	post_process_enabled = true

Detailed Description

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

NotebookCanvas is an actual view on the document.

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.

Class to deal with index scanning and classification.

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

Stores property information and global settings.

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:

{a b ... n}({t,t,...r}=value, {t,t,...r}=value, ...)

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


    ex:= A_{m n} ( A_{m n} + B_{m n} );
    crds:= m -> { t, r, \phi, \theta };
    vals:= { A_{t t} -> r, A_{r r} -> r**2, A_{t \phi} -> 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.

There can be any number of them active inside the NotebookWindow. Each DataCell in the notebook document has a corresponding VisualCell in the NotebookCanvas, which gets added by NotebookCanvas::add_cell.

Cells which contain child cells (e.g. CodeInput, which can contain child cells corresponding to the TeXView output) will also be hierarchically ordered in the visual tree. That is, any visual cell which can contain a child cell will have it stored inside a Gtk::Box inside the visual cell. Removing any cell will therefore also immediately remove the child cells.

Typedef Documentation

◆ dispatcher_t

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

◆ DTree

typedef tree<DataCell> cadabra::DTree

◆ Ex_ptr

using cadabra::Ex_ptr = typedef std::shared_ptr<Ex>

◆ flags_base_t

using cadabra::flags_base_t = typedef std::underlying_type_t<HashFlags>

◆ hashval_t

typedef uintptr_t cadabra::hashval_t

◆ multiplier_t

typedef mpq_class cadabra::multiplier_t

◆ nset_t

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

◆ rset_t

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

◆ tab_t

using cadabra::tab_t = typedef TableauBase::tab_t

Enumeration Type Documentation

◆ HashFlags

enum cadabra::HashFlags : unsigned int

Enumerator
HASH_DEFAULT
HASH_IGNORE_TOP_MULTIPLIER
HASH_IGNORE_MULTIPLIER
HASH_IGNORE_PRODUCT_ORDER
HASH_IGNORE_SUM_ORDER
HASH_IGNORE_INDEX_ORDER
HASH_IGNORE_PARENT_REL
HASH_IGNORE_BRACKET_TYPE
HASH_IGNORE_CHILDREN
HASH_IGNORE_NAMES
HASH_IGNORE_INDICES
HASH_IGNORE_CHILD_ORDER

Function Documentation

◆ add()

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

◆ apply_algo() [1/4]

template<class Algo >

Ex_ptr cadabra::apply_algo	(	Ex_ptr	ex,
		bool	deep,
		bool	repeat,
		unsigned int	depth
	)

◆ apply_algo() [2/4]

template<class Algo , typename Arg1 >

Ex_ptr cadabra::apply_algo	(	Ex_ptr	ex,
		Arg1	arg1,
		bool	deep,
		bool	repeat,
		unsigned int	depth
	)

◆ apply_algo() [3/4]

template<class Algo , typename Arg1 , typename Arg2 >

Ex_ptr cadabra::apply_algo	(	Ex_ptr	ex,
		Arg1	arg1,
		Arg2	arg2,
		bool	deep,
		bool	repeat,
		unsigned int	depth
	)

◆ apply_algo() [4/4]

template<class Algo , typename Arg1 , typename Arg2 , typename Arg3 >

Ex_ptr cadabra::apply_algo	(	Ex_ptr	ex,
		Arg1	arg1,
		Arg2	arg2,
		Arg3	arg3,
		bool	deep,
		bool	repeat,
		unsigned int	depth
	)

◆ apply_algo_preorder() [1/3]

template<class Algo >

Ex_ptr cadabra::apply_algo_preorder	(	Ex_ptr	ex,
		bool	deep,
		bool	repeat,
		unsigned int	depth
	)

◆ apply_algo_preorder() [2/3]

template<class Algo , typename Arg1 >

Ex_ptr cadabra::apply_algo_preorder	(	Ex_ptr	ex,
		Arg1	arg1,
		bool	deep,
		bool	repeat,
		unsigned int	depth
	)

◆ apply_algo_preorder() [3/3]

template<class Algo , typename Arg1 , typename Arg2 >

Ex_ptr cadabra::apply_algo_preorder	(	Ex_ptr	ex,
		Arg1	arg1,
		Arg2	arg2,
		bool	deep,
		bool	repeat,
		unsigned int	depth
	)

◆ call_post_process()

void cadabra::call_post_process	(	Kernel &	kernel,
		Ex_ptr	ex
	)

◆ capitalize_first()

std::string cadabra::capitalize_first ( std::string in )

◆ check_index_consistency()

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.

◆ cleanup_components()

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

◆ cleanup_derivative()

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

◆ cleanup_diagonal()

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

◆ cleanup_dispatch_deep()

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

◆ cleanup_exterior_derivative()

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

◆ cleanup_frac()

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

◆ cleanup_indexbracket()

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

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

◆ cleanup_kronecker()

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

◆ cleanup_numericalflat()

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

◆ cleanup_partialderivative()

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

◆ cleanup_powlike()

bool cadabra::cleanup_powlike	(	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).

◆ cleanup_productlike()

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

◆ cleanup_rational()

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

◆ cleanup_sqrt()

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

◆ cleanup_sub()

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

◆ cleanup_sumlike()

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

◆ cleanup_updown()

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').

◆ create_empty_scope()

Kernel * cadabra::create_empty_scope ( )

◆ create_scope_from_global()

Kernel * cadabra::create_scope_from_global ( )

◆ def_abstract_prop() [1/2]

template<typename BoundPropT >

BoundPropT::py_type cadabra::def_abstract_prop ( pybind11::module & m )

◆ def_abstract_prop() [2/2]

template<typename BoundPropT >

BoundPropT::py_type cadabra::def_abstract_prop	(	pybind11::module &	m,
		const std::string &	name
	)

◆ def_prop()

template<typename BoundPropT >

BoundPropT::py_type cadabra::def_prop ( pybind11::module & m )

◆ escape_quotes()

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

◆ Ex_add() [1/2]

Ex_ptr cadabra::Ex_add	(	const Ex_ptr	ex1,
		const Ex_ptr	ex2
	)

◆ Ex_add() [2/2]

Ex_ptr cadabra::Ex_add	(	const Ex_ptr	ex1,
		const Ex_ptr	ex2,
		Ex::iterator	top2
	)

◆ Ex_as_input()

std::string cadabra::Ex_as_input ( Ex_ptr ex )

◆ Ex_as_MMA()

std::string cadabra::Ex_as_MMA	(	Ex_ptr	ex,
		bool	use_unicode
	)

◆ Ex_as_repr()

std::string cadabra::Ex_as_repr ( Ex_ptr ex )

◆ Ex_as_sympy_string()

std::string cadabra::Ex_as_sympy_string ( Ex_ptr )

Similar to Ex_to_Sympy, but only producing a string which can be parsed by Sympy, instead of a full-fledged Sympy expression.

◆ Ex_as_tree()

std::string cadabra::Ex_as_tree ( Ex * ex )

◆ Ex_compare()

bool cadabra::Ex_compare	(	Ex_ptr	one,
		int	other
	)

◆ Ex_from_int()

Ex_ptr cadabra::Ex_from_int	(	int	num,
		bool
	)

◆ Ex_from_string()

Ex_ptr cadabra::Ex_from_string	(	const std::string &	ex_,
		bool	,
		Kernel *	kernel
	)

◆ Ex_get_mult()

pybind11::object cadabra::Ex_get_mult ( Ex_ptr ex )

◆ Ex_getitem()

Ex cadabra::Ex_getitem	(	Ex &	ex,
		int	index
	)

◆ Ex_getslice()

Ex cadabra::Ex_getslice	(	Ex_ptr	ex,
		pybind11::slice	slice
	)

◆ Ex_head()

std::string cadabra::Ex_head ( Ex_ptr ex )

◆ Ex_len()

size_t cadabra::Ex_len ( Ex_ptr ex )

◆ Ex_mul()

Ex_ptr cadabra::Ex_mul	(	const Ex_ptr	ex1,
		const Ex_ptr	ex2,
		Ex::iterator	top2
	)

◆ Ex_setitem()

void cadabra::Ex_setitem	(	Ex_ptr	ex,
		int	index,
		Ex	val
	)

◆ Ex_setitem_iterator()

void cadabra::Ex_setitem_iterator	(	Ex_ptr	ex,
		ExNode	en,
		Ex_ptr	val
	)

◆ Ex_sub() [1/2]

Ex_ptr cadabra::Ex_sub	(	const Ex_ptr	ex1,
		const Ex_ptr	ex2
	)

◆ Ex_sub() [2/2]

Ex_ptr cadabra::Ex_sub	(	const Ex_ptr	ex1,
		const Ex_ptr	ex2,
		Ex::iterator	top2
	)

◆ export_as_HTML()

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

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

◆ export_as_LaTeX()

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

Export a document to a single self-contained LaTeX file, with the exception of images which get saved as separate numbered files.

◆ export_as_python()

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

◆ fetch_from_python()

Ex_ptr cadabra::fetch_from_python	(	const std::string &	nm,
		pybind11::object	scope
	)

◆ flip_sign()

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

◆ get_globals()

pybind11::object cadabra::get_globals ( )

◆ get_locals()

pybind11::object cadabra::get_locals ( )

◆ get_name()

template<typename PropT >

std::string cadabra::get_name ( )

◆ get_progress_monitor()

ProgressMonitor * cadabra::get_progress_monitor ( )

◆ half()

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

◆ hash_compare()

bool cadabra::hash_compare	(	Ex::iterator	lhs,
		Ex::iterator	rhs,
		HashFlags	flags
	)

◆ hash_ex()

Ex_hasher::result_t cadabra::hash_ex	(	Ex::iterator	it,
		HashFlags	flags
	)

◆ HTML_recurse()

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

◆ init_algorithms() [1/2]

void cadabra::init_algorithms ( py::module & m )

◆ init_algorithms() [2/2]

void cadabra::init_algorithms ( pybind11::module & m )

◆ init_ex() [1/2]

void cadabra::init_ex ( pybind11::module & m )

◆ init_ex() [2/2]

void cadabra::init_ex ( py::module & m )

◆ init_ipython()

std::string cadabra::init_ipython ( )

◆ init_kernel()

void cadabra::init_kernel ( pybind11::module & m )

◆ init_packages()

void cadabra::init_packages ( pybind11::module & m )

◆ init_progress_monitor() [1/2]

void cadabra::init_progress_monitor ( pybind11::module & m )

◆ init_progress_monitor() [2/2]

void cadabra::init_progress_monitor ( py::module & m )

◆ init_properties() [1/2]

void cadabra::init_properties ( pybind11::module & m )

◆ init_properties() [2/2]

void cadabra::init_properties ( py::module & m )

◆ init_stopwatch() [1/2]

void cadabra::init_stopwatch ( pybind11::module & m )

◆ init_stopwatch() [2/2]

void cadabra::init_stopwatch ( py::module & m )

◆ init_tableau()

void cadabra::init_tableau ( pybind11::module & m )

◆ install_prefix()

std::string cadabra::install_prefix ( )

Return an absolute path to the installation path.

This is determined at runtime, to allow for binary distributions to be installed at any location.

◆ is_in()

template<typename T >

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

◆ JSON_deserialise()

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

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

◆ JSON_in_recurse()

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

◆ JSON_recurse()

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

◆ JSON_serialise()

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

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

◆ LaTeX_recurse()

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

◆ latex_to_html()

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.

◆ lhs()

cadabra::Ex cadabra::lhs ( Ex_ptr ex )

◆ list_properties()

pybind11::list cadabra::list_properties ( )

◆ map_sympy_wrapper()

Ex_ptr cadabra::map_sympy_wrapper	(	Ex_ptr	ex,
		std::string	head,
		pybind11::args	args
	)

◆ one()

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

◆ operator&() [1/2]

HashFlags cadabra::operator &	(	HashFlags	lhs,
		HashFlags	rhs
	)

◆ operator&() [2/2]

HashFlags cadabra::operator &	(	HashFlags	lhs,
		HashFlags	rhs
	)

◆ operator&=() [1/2]

HashFlags& cadabra::operator &=	(	HashFlags &	lhs,
		HashFlags	rhs
	)

◆ operator&=() [2/2]

HashFlags& cadabra::operator &=	(	HashFlags &	lhs,
		HashFlags	rhs
	)

◆ operator<()

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

◆ operator|()

HashFlags cadabra::operator\|	(	HashFlags	lhs,
		HashFlags	rhs
	)

◆ operator|=()

HashFlags & cadabra::operator\|=	(	HashFlags &	lhs,
		HashFlags	rhs
	)

◆ operator~()

HashFlags cadabra::operator~ ( HashFlags flags )

◆ pre_clean_dispatch()

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

◆ pre_clean_dispatch_deep()

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

◆ print_tree()

std::string cadabra::print_tree ( Ex * ex )

◆ ProgressMonitor_totals_helper()

pybind11::list cadabra::ProgressMonitor_totals_helper ( ProgressMonitor & self )

◆ push_down_multiplier()

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

◆ PYBIND11_MODULE()

cadabra::PYBIND11_MODULE	(	cadabra2	,
		m
	)

◆ python_recurse()

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

◆ read_manual()

std::string cadabra::read_manual	(	const char *	category,
		const char *	name
	)

◆ replace_all()

std::string cadabra::replace_all	(	std::string const &	original,
		std::string const &	from,
		std::string const &	to
	)

Replace all occurrances of 'from' with 'to', return result (does not replace in-place).

◆ rhs()

cadabra::Ex cadabra::rhs ( Ex_ptr ex )

◆ scope_has() [1/2]

bool cadabra::scope_has	(	const pybind11::dict &	dict,
		const std::string &	obj
	)

◆ scope_has() [2/2]

bool cadabra::scope_has	(	const py::dict &	dict,
		const std::string &	obj
	)

◆ subtree_equal()

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

◆ subtree_exact_equal()

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
	)

◆ subtree_exact_less()

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
	)

◆ subtree_less()

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

◆ SympyBridge_init()

std::shared_ptr<sympy::SympyBridge> cadabra::SympyBridge_init ( std::shared_ptr< Ex > ex )

◆ tab_str()

std::string cadabra::tab_str ( const tab_t & tab )

◆ terms()

pybind11::list cadabra::terms ( Ex_ptr ex )

◆ to_long()

long cadabra::to_long ( multiplier_t mul )

◆ to_string()

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

◆ tree_equal()

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

◆ tree_exact_equal()

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
	)

◆ tree_exact_less()

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
	)

◆ tree_less()

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.

◆ unichar()

const char * cadabra::unichar ( kunichar c )

◆ zero()

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

Variable Documentation

◆ name_set

nset_t cadabra::name_set

◆ post_process_enabled

bool cadabra::post_process_enabled = true

◆ rat_set

rset_t cadabra::rat_set

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ dispatcher_t

◆ DTree

◆ Ex_ptr

◆ flags_base_t

◆ hashval_t

◆ multiplier_t

◆ nset_t

◆ rset_t

◆ tab_t

Enumeration Type Documentation

◆ HashFlags

Function Documentation

◆ add()

◆ apply_algo() [1/4]

◆ apply_algo() [2/4]

◆ apply_algo() [3/4]

◆ apply_algo() [4/4]

◆ apply_algo_preorder() [1/3]

◆ apply_algo_preorder() [2/3]

◆ apply_algo_preorder() [3/3]

◆ call_post_process()

◆ capitalize_first()

◆ check_index_consistency()

◆ cleanup_components()

◆ cleanup_derivative()

◆ cleanup_diagonal()

◆ cleanup_dispatch_deep()

◆ cleanup_exterior_derivative()

◆ cleanup_frac()

◆ cleanup_indexbracket()

◆ cleanup_kronecker()

◆ cleanup_numericalflat()

◆ cleanup_partialderivative()

◆ cleanup_powlike()

◆ cleanup_productlike()

◆ cleanup_rational()

◆ cleanup_sqrt()

◆ cleanup_sub()

◆ cleanup_sumlike()

◆ cleanup_updown()

◆ create_empty_scope()

◆ create_scope_from_global()

◆ def_abstract_prop() [1/2]

◆ def_abstract_prop() [2/2]

◆ def_prop()

◆ escape_quotes()

◆ Ex_add() [1/2]

◆ Ex_add() [2/2]

◆ Ex_as_input()

◆ Ex_as_MMA()

◆ Ex_as_repr()

◆ Ex_as_sympy_string()

◆ Ex_as_tree()

◆ Ex_compare()

◆ Ex_from_int()

◆ Ex_from_string()

◆ Ex_get_mult()

◆ Ex_getitem()

◆ Ex_getslice()

◆ Ex_head()

◆ Ex_len()

◆ Ex_mul()

◆ Ex_setitem()

◆ Ex_setitem_iterator()

◆ Ex_sub() [1/2]

◆ Ex_sub() [2/2]

◆ export_as_HTML()

◆ export_as_LaTeX()

◆ export_as_python()

◆ fetch_from_python()

◆ flip_sign()

◆ get_globals()