Cadabra
Computer algebra system for field theory problems
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
cadabra Namespace Reference

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< DataCellDTree
 
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_trset_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)
 
HashFlagsoperator|= (HashFlags &lhs, HashFlags rhs)
 
HashFlagsoperator&= (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)
 
HashFlagsoperator&= (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::SympyBridgeSympyBridge_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)
 
Kernelcreate_scope ()
 
 Setup of kernels in current scope, callable from Python.
More...
 
Kernelcreate_scope_from_global ()
 
Kernelcreate_empty_scope ()
 
Kernelget_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)
 
ProgressMonitorget_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.

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

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

◆ 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