Functions to handle the exchange properties of two or more symbols in a product.
More...
|
bool | is_index (const Kernel &kernel, Ex::iterator it) |
|
bool | has_indices (const cadabra::Kernel &kernel, cadabra::Ex::iterator it) |
|
bool | is_free_index (Adjform::value_type idx) |
|
bool | is_dummy_index (Adjform::value_type idx) |
|
bool | has_indices (const Kernel &kernel, Ex::iterator it) |
|
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 &, 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 &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...
|
|
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...
|
|
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 &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_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) |
|
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 | 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) |
|
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) |
|
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.
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.
- 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.
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.