![]() |
Cadabra
Computer algebra system for field theory problems
|
Functions to handle the exchange properties of two or more symbols in a product. More...
Namespaces | |
symbols | |
Classes | |
class | Accent |
class | ActionAddCell |
class | ActionBase |
class | ActionCompleteText |
class | ActionEraseText |
class | ActionInsertText |
class | ActionPositionCursor |
class | ActionRemoveCell |
class | ActionSetRunStatus |
class | ActionSplitCell |
class | Adjform |
Representation of the index structure of a tensor monomial, using a storage format which resembles an adjacency matrix. More... | |
class | Algorithm |
class | AntiCommuting |
class | AntiSymmetric |
class | BoundProperty |
class | BoundPropertyBase |
class | CadabraJupyter |
class | canonicalise |
class | ChooseColoursDialog |
class | CodeInput |
class | collect_components |
class | collect_factors |
class | collect_terms |
class | combine |
class | Commuting |
class | CommutingAsProduct |
class | CommutingAsSum |
class | CommutingBehaviour |
class | complete |
class | component |
class | ComputeThread |
class | Console |
class | Coordinate |
class | DAntiSymmetric |
class | DataCell |
class | decompose |
class | decompose_product |
class | Depends |
class | DependsBase |
class | DependsInherit |
class | Derivative |
class | Determinant |
class | Diagonal |
class | DifferentialForm |
class | DifferentialFormBase |
class | DiracBar |
class | DisplayBase |
class | DisplayMMA |
class | DisplaySympy |
class | DisplayTerminal |
class | DisplayTeX |
class | Distributable |
class | distribute |
class | DocumentThread |
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 | Ex |
class | Ex_comparator |
class | Ex_hasher |
class | Ex_is_equivalent |
class | Ex_is_less |
class | exchange |
class | expand |
class | expand_delta |
class | expand_diracbar |
class | expand_dummies |
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 |
class | ImageView |
class | ImaginaryI |
class | ImplicitIndex |
class | index_iterator |
class | IndexClassifier |
class | IndexInherit |
class | IndexMap |
To ensure consistency when creating adjforms out of two different Ex objects an IndexMap object is required which keeps track of which numeric index represents which index name. More... | |
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 |
class | Integral |
class | integrate_by_parts |
class | InverseMetric |
class | InverseVielbein |
struct | iter_indices |
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 |
class | map_sympy |
class | Matrix |
class | meld |
class | Metric |
class | nevaluate |
class | NEvaluator |
class | NonCommuting |
class | NotebookCanvas |
class | NotebookWindow |
class | nset_it_less |
class | NTensor |
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 | ProjectedAdjform |
Representation of a sum of tensor monomials, each having the same tensor names, but with different index positions. More... | |
class | Properties |
class | property |
FIXME: the above two need to be merged, because parse may need access to the actual pattern tree, and once we are there, we may as well do checking. 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 |
class | sort_product |
class | sort_spinors |
class | sort_sum |
class | SortOrder |
class | Spinor |
class | split |
class | split_gamma |
class | split_index |
struct | split_it |
class | str_node |
class | substitute |
class | sym |
class | Symbol |
class | Symmetric |
class | tab_basics |
class | tabdimension |
class | Tableau |
Property representing a Young tableau with unlabelled boxes. More... | |
class | TableauBase |
class | TableauInherit |
Property which makes a node inherit the TableauBase properties of child nodes. More... | |
class | TableauSymmetry |
class | take_match |
class | TerminalStream |
class | TeXEngine |
class | TeXView |
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 |
class | Vielbein |
class | VisualCell |
class | Weight |
class | WeightBase |
class | WeightInherit |
class | WeylTensor |
class | young_project |
class | young_project_product |
class | young_project_tensor |
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 | |
bool | is_coordinate (const Kernel &kernel, Ex::iterator it) |
bool | is_index (const Kernel &kernel, Ex::iterator it, bool include_coordinates) |
ProjectedAdjform | operator+ (ProjectedAdjform lhs, const ProjectedAdjform &rhs) |
ProjectedAdjform | operator* (ProjectedAdjform lhs, const ProjectedAdjform::integer_type &rhs) |
std::string | escape_quotes (const std::string &) |
std::string | cdb2python (const std::string &, bool display) |
std::string | cdb2python_string (const std::string &, bool display) |
std::string | convert_line (const std::string &, std::string &lhs, std::string &rhs, std::string &op, std::string &indent, bool display) |
std::string | cnb2python (const std::string &, bool for_standalone) |
void | cleanup_dispatch (const Kernel &kernel, Ex &tr, Ex::iterator &it) |
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_fraclike (const Kernel &k, Ex &, Ex::iterator &it) |
Individual node cleanup routines. More... | |
bool | cleanup_powlike (const Kernel &k, Ex &tr, Ex::iterator &it) |
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 &k, 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) |
bool | cleanup_comma (const Kernel &k, Ex &tr, Ex::iterator &it) |
bool | cleanup_tie (const Kernel &k, Ex &tr, Ex::iterator &it) |
void | cleanup_dispatch_deep (const Kernel &k, Ex &tr, dispatcher_t dispatch) |
void | cleanup_dispatch_deep (const Kernel &k, Ex &tr, Ex::iterator &, dispatcher_t dispatch) |
int | subtree_compare (const Properties *properties, Ex::iterator one, Ex::iterator two, int mod_prel, bool, int compare_multiplier, bool literal_wildcards) |
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, nlohmann::json &) |
void | JSON_deserialise (const std::string &, DTree &) |
Load a document from .cnb format, i.e. the inverse of the above. More... | |
void | JSON_in_recurse (DTree &doc, DTree::iterator loc, const nlohmann::json &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, bool for_embedding=false) |
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, bool for_embedding) |
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) |
nlohmann::json | ipynb2cnb (const nlohmann::json &) |
Replace all occurrences of a substring in the original string. More... | |
nlohmann::json | cnb2ipynb (const nlohmann::json &) |
Convert the JSON of a Cadabra notebook to a Jupyter notebook. More... | |
template<typename DisplayType > | |
std::string | ex_to_string (const Kernel &kernel, const Ex &ex) |
template<typename DisplayType > | |
std::string | ex_to_string (const Kernel &kernel, Ex::iterator it) |
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) |
int | list_size (const Ex &tr, Ex::iterator it) |
Ex::iterator | find_in_subtree (const Ex &tr, Ex::iterator it, std::function< bool(Ex::iterator)> f, bool including_head) |
Ex::iterator | find_in_list (const Ex &tr, Ex::iterator it, std::function< Ex::iterator(Ex::iterator)> f) |
Ex | make_list (Ex el) |
template<typename T > | |
T::iterator | do_subtree (const T &tr, typename T::iterator it, std::function< typename T::iterator(typename T::iterator)> f) |
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) |
std::string | install_prefix () |
Return an absolute path to the installation path. More... | |
const char * | cmake_install_prefix () |
Just get a constant char array with the install prefix. More... | |
std::ostream & | operator<< (std::ostream &, const NTensor &) |
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) |
double | to_double (multiplier_t mul) |
std::string | to_string (long num) |
void | multiply (rset_t::iterator &num, multiplier_t fac) |
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) |
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) |
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) |
void | init_algorithms (pybind11::module &m) |
bool | Ex_compare (Ex_ptr one, Ex_ptr other) |
bool | Ex_compare (Ex_ptr one, int other) |
Ex_ptr | Ex_add (const Ex_ptr ex1, const ExNode ex2) |
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_join (const Ex_ptr ex1, const Ex_ptr ex2) |
Ex_ptr | Ex_mul (const Ex_ptr ex1, const Ex_ptr ex2) |
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) |
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) |
Ex_ptr | fetch_from_python (const std::string &nm, pybind11::object scope) |
std::string | Ex_as_str (Ex_ptr ex) |
std::string | Ex_as_repr (Ex_ptr ex) |
std::string | Ex_as_latex (Ex_ptr ex) |
pybind11::object | Ex_as_sympy (Ex_ptr ex) |
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) |
Ex_comparator::match_t | ExNode_compare (const ExNode &lhs, const ExNode &rhs, const std::string &use_props, bool ignore_parent_rel) |
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) |
long | Ex_int_cast (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) |
void | Ex_cleanup (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 () |
Kernel * | create_scope_from_global () |
Kernel * | create_empty_scope () |
Kernel * | get_kernel_from_scope () |
void | kernel_configure_warnings (Kernel &kernel, pybind11::kwargs kwargs) |
void | init_kernel (pybind11::module &m) |
std::string | init_ipython () |
PYBIND11_MODULE (cadabra2, m) | |
void | init_ntensor (py::module &m) |
void | init_ntensor (pybind11::module &m) |
void | compile_package (const std::string &in_name, const std::string &out_name) |
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 () |
std::vector< Ex > | indices_get_all (const Indices *indices, bool include_wildcards) |
Ex | indices_get_dummy (const Indices *indices, const Ex_ptr &ex) |
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 |
Functions to handle the exchange properties of two or more symbols in a product.
NotebookCanvas is an actual view on the document.
See tests/components.cdb for basic samples.
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).
Cadabra kernel that keeps all state information that needs to be passed around to algorithms and properties. Stores property information and global settings.
Class to hold numerical values structured in tensor form, that is, a multi-dimensional array.
Handle the entire preclean stage, which turns a parsed expression into an expression which satisfies the Cadabra conventions. This does not involve the property system.
Evaluate a tensorial expression to components, performing all dummy index sums.
Components nodes have the following structure:
\components_{a b ... n}({t,t,...r}=value, {t,t,...r}=value, ...)
\verbatim \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
\verbatim 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.
\verbatim {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 tree<DataCell> cadabra::DTree |
using cadabra::Ex_ptr = typedef std::shared_ptr<Ex> |
using cadabra::flags_base_t = typedef std::underlying_type_t<HashFlags> |
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 |
using cadabra::tab_t = typedef TableauBase::tab_t |
enum cadabra::HashFlags : unsigned int |
void cadabra::add | ( | rset_t::iterator & | num, |
multiplier_t | fac | ||
) |
Ex_ptr cadabra::apply_algo | ( | Ex_ptr | ex, |
Arg1 | arg1, | ||
Arg2 | arg2, | ||
Arg3 | arg3, | ||
bool | deep, | ||
bool | repeat, | ||
unsigned int | depth | ||
) |
Ex_ptr cadabra::apply_algo | ( | Ex_ptr | ex, |
Arg1 | arg1, | ||
Arg2 | arg2, | ||
bool | deep, | ||
bool | repeat, | ||
unsigned int | depth | ||
) |
Ex_ptr cadabra::apply_algo | ( | Ex_ptr | ex, |
Arg1 | arg1, | ||
bool | deep, | ||
bool | repeat, | ||
unsigned int | depth | ||
) |
Ex_ptr cadabra::apply_algo | ( | Ex_ptr | ex, |
bool | deep, | ||
bool | repeat, | ||
unsigned int | depth | ||
) |
Ex_ptr cadabra::apply_algo_preorder | ( | Ex_ptr | ex, |
Arg1 | arg1, | ||
Arg2 | arg2, | ||
bool | deep, | ||
bool | repeat, | ||
unsigned int | depth | ||
) |
Ex_ptr cadabra::apply_algo_preorder | ( | Ex_ptr | ex, |
Arg1 | arg1, | ||
bool | deep, | ||
bool | repeat, | ||
unsigned int | depth | ||
) |
Ex_ptr cadabra::apply_algo_preorder | ( | Ex_ptr | ex, |
bool | deep, | ||
bool | repeat, | ||
unsigned int | depth | ||
) |
std::string cadabra::capitalize_first | ( | std::string | in | ) |
std::string cadabra::cdb2python_string | ( | const std::string & | blk, |
bool | display | ||
) |
Generic tool to check for index inconsistencies independent of running any algorithm.
void cadabra::cleanup_dispatch_deep | ( | const Kernel & | k, |
Ex & | tr, | ||
Ex::iterator & | , | ||
dispatcher_t | dispatch | ||
) |
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).
Convert parser output which indicates an indexbracket to an actual indexbracket node.
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').
const char * cadabra::cmake_install_prefix | ( | ) |
Just get a constant char array with the install prefix.
nlohmann::json cadabra::cnb2ipynb | ( | const nlohmann::json & | root | ) |
Convert the JSON of a Cadabra notebook to a Jupyter notebook.
Kernel * cadabra::create_empty_scope | ( | ) |
Kernel * cadabra::create_scope_from_global | ( | ) |
BoundPropT::py_type cadabra::def_abstract_prop | ( | pybind11::module & | m | ) |
BoundPropT::py_type cadabra::def_abstract_prop | ( | pybind11::module & | m, |
const std::string & | name | ||
) |
BoundPropT::py_type cadabra::def_prop | ( | pybind11::module & | m | ) |
std::string cadabra::escape_quotes | ( | const std::string & | line | ) |
std::string cadabra::Ex_as_input | ( | Ex_ptr | ex | ) |
std::string cadabra::Ex_as_MMA | ( | Ex_ptr | ex, |
bool | use_unicode | ||
) |
std::string cadabra::Ex_as_repr | ( | Ex_ptr | ex | ) |
std::string cadabra::Ex_as_sympy_string | ( | Ex_ptr | ex | ) |
Similar to Ex_to_Sympy, but only producing a string which can be parsed by Sympy, instead of a full-fledged Sympy expression.
std::string cadabra::Ex_as_tree | ( | Ex * | ex | ) |
void cadabra::Ex_cleanup | ( | Ex_ptr | ex | ) |
bool cadabra::Ex_compare | ( | Ex_ptr | one, |
int | other | ||
) |
Ex_ptr cadabra::Ex_from_int | ( | int | num, |
bool | |||
) |
pybind11::object cadabra::Ex_get_mult | ( | Ex_ptr | ex | ) |
std::string cadabra::Ex_head | ( | Ex_ptr | ex | ) |
long cadabra::Ex_int_cast | ( | Ex_ptr | ex | ) |
size_t cadabra::Ex_len | ( | Ex_ptr | ex | ) |
std::string cadabra::ex_to_string | ( | const Kernel & | kernel, |
const Ex & | ex | ||
) |
std::string cadabra::ex_to_string | ( | const Kernel & | kernel, |
Ex::iterator | it | ||
) |
Ex_comparator::match_t cadabra::ExNode_compare | ( | const ExNode & | lhs, |
const ExNode & | rhs, | ||
const std::string & | use_props, | ||
bool | ignore_parent_rel | ||
) |
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.
std::string cadabra::export_as_LaTeX | ( | const DTree & | doc, |
const std::string & | image_file_base, | ||
bool | for_embedding = false |
||
) |
Export a document to a single self-contained LaTeX file, with the exception of images which get saved as separate numbered files.
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).
Ex_ptr cadabra::fetch_from_python | ( | const std::string & | nm, |
pybind11::object | scope | ||
) |
void cadabra::flip_sign | ( | rset_t::iterator & | num | ) |
pybind11::object cadabra::get_globals | ( | ) |
pybind11::object cadabra::get_locals | ( | ) |
std::string cadabra::get_name | ( | ) |
ProgressMonitor * cadabra::get_progress_monitor | ( | ) |
void cadabra::half | ( | rset_t::iterator & | num | ) |
bool cadabra::hash_compare | ( | Ex::iterator | lhs, |
Ex::iterator | rhs, | ||
HashFlags | flags | ||
) |
Ex_hasher::result_t cadabra::hash_ex | ( | Ex::iterator | it, |
HashFlags | flags | ||
) |
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 = "" |
||
) |
void cadabra::init_algorithms | ( | py::module & | m | ) |
void cadabra::init_algorithms | ( | pybind11::module & | m | ) |
void cadabra::init_ex | ( | py::module & | m | ) |
void cadabra::init_ex | ( | pybind11::module & | m | ) |
std::string cadabra::init_ipython | ( | ) |
void cadabra::init_kernel | ( | pybind11::module & | m | ) |
void cadabra::init_ntensor | ( | py::module & | m | ) |
void cadabra::init_ntensor | ( | pybind11::module & | m | ) |
void cadabra::init_packages | ( | pybind11::module & | m | ) |
void cadabra::init_progress_monitor | ( | py::module & | m | ) |
void cadabra::init_progress_monitor | ( | pybind11::module & | m | ) |
void cadabra::init_properties | ( | py::module & | m | ) |
void cadabra::init_properties | ( | pybind11::module & | m | ) |
void cadabra::init_stopwatch | ( | py::module & | m | ) |
void cadabra::init_stopwatch | ( | pybind11::module & | m | ) |
void cadabra::init_tableau | ( | pybind11::module & | m | ) |
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. Note that this cannot be used if the binary running the code was a python interpreter.
nlohmann::json cadabra::ipynb2cnb | ( | const nlohmann::json & | root | ) |
bool cadabra::is_coordinate | ( | const Kernel & | kernel, |
Ex::iterator | it | ||
) |
bool cadabra::is_in | ( | const T & | val, |
const std::initializer_list< T > & | list | ||
) |
bool cadabra::is_index | ( | const Kernel & | kernel, |
Ex::iterator | it, | ||
bool | include_coordinates | ||
) |
void cadabra::JSON_deserialise | ( | const std::string & | cj, |
DTree & | doc | ||
) |
Load a document from .cnb format, i.e. the inverse of the above.
void cadabra::JSON_in_recurse | ( | DTree & | doc, |
DTree::iterator | loc, | ||
const nlohmann::json & | cells | ||
) |
void cadabra::JSON_recurse | ( | const DTree & | doc, |
DTree::iterator | it, | ||
nlohmann::json & | 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::kernel_configure_warnings | ( | Kernel & | kernel, |
pybind11::kwargs | kwargs | ||
) |
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, | ||
bool | for_embedding | ||
) |
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.
cadabra::Ex cadabra::lhs | ( | Ex_ptr | ex | ) |
pybind11::list cadabra::list_properties | ( | ) |
void cadabra::one | ( | rset_t::iterator & | num | ) |
ProjectedAdjform cadabra::operator* | ( | ProjectedAdjform | lhs, |
const ProjectedAdjform::integer_type & | rhs | ||
) |
ProjectedAdjform cadabra::operator+ | ( | ProjectedAdjform | lhs, |
const ProjectedAdjform & | rhs | ||
) |
bool cadabra::operator< | ( | const exchange::tensor_type_t & | one, |
const exchange::tensor_type_t & | two | ||
) |
std::ostream& cadabra::operator<< | ( | std::ostream & | , |
const NTensor & | |||
) |
std::string cadabra::print_tree | ( | Ex * | ex | ) |
pybind11::list cadabra::ProgressMonitor_totals_helper | ( | ProgressMonitor & | self | ) |
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).
cadabra::PYBIND11_MODULE | ( | cadabra2 | , |
m | |||
) |
void cadabra::python_recurse | ( | const DTree & | doc, |
DTree::iterator | it, | ||
std::ostringstream & | str | ||
) |
std::string cadabra::read_manual | ( | const char * | category, |
const char * | name | ||
) |
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).
cadabra::Ex cadabra::rhs | ( | Ex_ptr | ex | ) |
bool cadabra::scope_has | ( | const py::dict & | dict, |
const std::string & | obj | ||
) |
bool cadabra::scope_has | ( | const pybind11::dict & | dict, |
const std::string & | obj | ||
) |
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 | ||
) |
std::shared_ptr<sympy::SympyBridge> cadabra::SympyBridge_init | ( | std::shared_ptr< Ex > | ex | ) |
std::string cadabra::tab_str | ( | const tab_t & | tab | ) |
pybind11::list cadabra::terms | ( | Ex_ptr | ex | ) |
double cadabra::to_double | ( | multiplier_t | mul | ) |
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 | ) |
nset_t cadabra::name_set |
bool cadabra::post_process_enabled = true |
rset_t cadabra::rat_set |