cadabra2  2.2.6
About: Cadabra2 is a symbolic computer algebra system designed for field-theory problems (command-line and TeXmacs interface). Version 2.
  Fossies Dox: cadabra2-2.2.6.tar.gz  ("inofficial" and yet experimental doxygen-generated source code documentation)  

cadabra::Algorithm Class Referenceabstract

#include <Algorithm.hh>

Inherits cadabra::IndexClassifier.

Inherited by cadabra::canonicalise, cadabra::collect_components, cadabra::collect_factors, cadabra::collect_terms, cadabra::combine, cadabra::complete, cadabra::decompose, cadabra::decompose_product, cadabra::distribute, cadabra::drop_keep_weight, cadabra::einsteinify, cadabra::eliminate_converter, cadabra::eliminate_kronecker, cadabra::epsilon_to_delta, cadabra::evaluate, cadabra::expand, cadabra::expand_delta, cadabra::expand_diracbar, cadabra::expand_power, cadabra::explicit_indices, cadabra::factor_in, cadabra::factor_out, cadabra::fierz, cadabra::flatten_product, cadabra::flatten_sum, cadabra::indexsort, cadabra::integrate_by_parts, cadabra::join_gamma, cadabra::keep_terms, cadabra::lower_free_indices, cadabra::map_mma, cadabra::map_sympy, cadabra::order [virtual], cadabra::product_rule, cadabra::reduce_delta, cadabra::rename_dummies, cadabra::replace_match, cadabra::rewrite_indices, cadabra::simplify, cadabra::sort_product, cadabra::sort_spinors, cadabra::sort_sum, cadabra::split_gamma, cadabra::split_index, cadabra::substitute, cadabra::sym [virtual], cadabra::tab_basics, cadabra::tabdimension, cadabra::take_match, cadabra::untrace, cadabra::unwrap, cadabra::unzoom, cadabra::vary, cadabra::young_project, cadabra::young_project_product, cadabra::young_project_tensor, cadabra::young_reduce, and cadabra::zoom.

Collaboration diagram for cadabra::Algorithm:

Public Types

typedef Ex::iterator iterator
 
typedef Ex::post_order_iterator post_order_iterator
 
typedef Ex::sibling_iterator sibling_iterator
 
typedef Ex::result_t result_t
 
- Public Types inherited from cadabra::IndexClassifier
typedef std::multimap< Ex, Ex::iterator, tree_exact_less_for_indexmap_objindex_map_t
 
typedef std::map< Ex::iterator, int, Ex::iterator_base_less > index_position_map_t
 A map from the position of each index to the sequential index. More...
 

Public Member Functions

 Algorithm (const Kernel &, Ex &)
 
virtual ~Algorithm ()
 
void set_progress_monitor (ProgressMonitor *)
 
result_t apply_generic (bool deep=true, bool repeat=false, unsigned int depth=0)
 
result_t apply_generic (iterator &, bool deep, bool repeat, unsigned int depth)
 
result_t apply_pre_order (bool repeat=false)
 
bool check_consistency (iterator) const
 Given an expression top node, check index consistency. More...
 
bool check_index_consistency (iterator) const
 
bool check_degree_consistency (iterator) const
 Given an expression top node, check differential form degree consistency. More...
 
void report_progress (const std::string &, int todo, int done, int count=2)
 
index_iterator begin_index (iterator it) const
 
index_iterator end_index (iterator it) const
 
unsigned int number_of_indices (iterator it)
 
bool rename_replacement_dummies (iterator, bool still_inside_algo=false)
 
- Public Member Functions inherited from cadabra::IndexClassifier
 IndexClassifier (const Kernel &)
 
void fill_index_position_map (Ex::iterator, const index_map_t &, index_position_map_t &) const
 
void fill_map (index_map_t &, Ex::sibling_iterator, Ex::sibling_iterator) const
 
void print_classify_indices (std::ostream &, Ex::iterator) const
 
void determine_intersection (index_map_t &one, index_map_t &two, index_map_t &target, bool move_out=false) const
 
void classify_add_index (Ex::iterator it, index_map_t &ind_free, index_map_t &ind_dummy) const
 
void classify_indices_up (Ex::iterator, index_map_t &ind_free, index_map_t &ind_dummy) const
 
void classify_indices (Ex::iterator, index_map_t &ind_free, index_map_t &ind_dummy) const
 
int max_numbered_name_one (const std::string &nm, const index_map_t *one) const
 
int max_numbered_name (const std::string &, const index_map_t *m1, const index_map_t *m2=0, const index_map_t *m3=0, const index_map_t *m4=0, const index_map_t *m5=0) const
 
Ex get_dummy (const list_property *, const index_map_t *m1, const index_map_t *m2=0, const index_map_t *m3=0, const index_map_t *m4=0, const index_map_t *m5=0) const
 
Ex get_dummy (const list_property *, Ex::iterator) const
 
Ex get_dummy (const list_property *, Ex::iterator, Ex::iterator) const
 
bool index_in_set (Ex, const index_map_t *) const
 
void dumpmap (std::ostream &, const index_map_t &) const
 
index_map_t::iterator find_modulo_parent_rel (Ex::iterator it, index_map_t &imap) const
 Find an index in the set, not taking into account index position. More...
 

Static Public Member Functions

static unsigned int number_of_indices (const Properties &, iterator it)
 
static unsigned int number_of_direct_indices (iterator it)
 

Public Attributes

bool interrupted
 
unsigned int number_of_calls
 
unsigned int number_of_modifications
 
bool suppress_normal_output
 
bool discard_command_node
 
Stopwatch index_sw
 
Stopwatch get_dummy_sw
 
Stopwatch report_progress_stopwatch
 

Protected Types

typedef std::pair< sibling_iterator, sibling_iteratorrange_t
 Finding objects in sets. More...
 
typedef std::vector< range_trange_vector_t
 

Protected Member Functions

virtual bool can_apply (iterator)=0
 
virtual result_t apply (iterator &)=0
 
int index_parity (iterator) const
 
bool contains (sibling_iterator from, sibling_iterator to, sibling_iterator arg)
 
void find_argument_lists (range_vector_t &, bool only_comma_lists=true) const
 
template<class Iter >
range_vector_t::iterator find_arg_superset (range_vector_t &, Iter st, Iter nd)
 
range_vector_t::iterator find_arg_superset (range_vector_t &, sibling_iterator it)
 
unsigned int locate_single_object (Ex::iterator obj_to_find, Ex::iterator st, Ex::iterator nd, std::vector< unsigned int > &store)
 
bool locate_object_set (const Ex &objs, Ex::iterator st, Ex::iterator nd, std::vector< unsigned int > &store)
 
bool is_termlike (iterator)
 
bool is_factorlike (iterator)
 
bool is_single_term (iterator)
 
bool is_nonprod_factor_in_prod (iterator)
 
bool prod_wrap_single_term (iterator &)
 
bool prod_unwrap_single_term (iterator &)
 
bool sum_wrap_single_term (iterator &)
 
bool sum_unwrap_single_term (iterator &)
 
void force_node_wrap (iterator &, std::string)
 
bool separated_by_derivative (iterator, iterator, iterator check_dependence) const
 
void pushup_multiplier (iterator)
 
template<class BinaryPredicate >
unsigned int intersection_number (sibling_iterator, sibling_iterator, sibling_iterator, sibling_iterator, BinaryPredicate) const
 
void node_zero (iterator)
 
void node_one (iterator)
 
void node_integer (iterator, int)
 

Static Protected Member Functions

static bool less_without_numbers (nset_t::iterator, nset_t::iterator)
 
static bool equal_without_numbers (nset_t::iterator, nset_t::iterator)
 
static bool compare_ (const str_node &, const str_node &)
 

Protected Attributes

Extr
 
ProgressMonitorpm
 
bool traverse_ldots
 
- Protected Attributes inherited from cadabra::IndexClassifier
const Kernelkernel
 

Private Member Functions

result_t apply_once (Ex::iterator &it)
 
result_t apply_deep (Ex::iterator &it)
 
void propagate_zeroes (post_order_iterator &, const iterator &)
 

Detailed Description

Base class for all algorithms, containing generic routines and in particular the logic for index classification. Also contains static algorithms acting on Ex objects which require property information and can therefore not be a member of Ex.

In order to implement a new algorithm, subclass Algorithm and implement the abstract members Algorithm::can_apply and Algorithm::apply (see there for further documentation). The general logic is that the implementation of Algorithm::apply(iterator&) is not allowed to make the node pointed at by the iterator invalid. If the algorithm makes the node vanish, it should indicate so by setting its multiplier to zero; the calling logic will then take care of cleaning up the subtree at the node.

The algorithm is, however, allowed to change the node itself or replace it with another one, as long as it updates the iterator.

Definition at line 59 of file Algorithm.hh.

Member Typedef Documentation

◆ iterator

typedef Ex::iterator cadabra::Algorithm::iterator

Definition at line 70 of file Algorithm.hh.

◆ post_order_iterator

typedef Ex::post_order_iterator cadabra::Algorithm::post_order_iterator

Definition at line 71 of file Algorithm.hh.

◆ range_t

Finding objects in sets.

Definition at line 151 of file Algorithm.hh.

◆ range_vector_t

typedef std::vector<range_t> cadabra::Algorithm::range_vector_t
protected

Definition at line 152 of file Algorithm.hh.

◆ result_t

Definition at line 73 of file Algorithm.hh.

◆ sibling_iterator

typedef Ex::sibling_iterator cadabra::Algorithm::sibling_iterator

Definition at line 72 of file Algorithm.hh.

Constructor & Destructor Documentation

◆ Algorithm()

Algorithm::Algorithm ( const Kernel k,
Ex tr_ 
)

Initialise the algorithm with a reference to the expression tree, but do not yet do anything with this tree. Algorithms are not typically allowed to mess with the settings in the Kernel, so it is passed const.

Definition at line 45 of file Algorithm.cc.

◆ ~Algorithm()

Algorithm::~Algorithm ( )
virtual

Definition at line 57 of file Algorithm.cc.

Member Function Documentation

◆ apply()

◆ apply_deep()

◆ apply_generic() [1/2]

Algorithm::result_t Algorithm::apply_generic ( bool  deep = true,
bool  repeat = false,
unsigned int  depth = 0 
)

The main entry points for running algorithms, which traverse the tree post-order ('child before parent'). The 'deep' flag indicates whether sub-expressions should be acted on too. The 'repeat' flag indicates whether the algorithm should be applied until the expression no longer changes. The 'depth' flag, if not equal to -1, indicates the depth in the tree where the algorithm should start applying.

Definition at line 102 of file Algorithm.cc.

References tree< T, tree_node_allocator >::begin(), and tr.

Referenced by cadabra::decompose::apply(), cadabra::young_project_product::apply(), project(), cadabra::evaluate::simplify_components(), test1(), and test2().

◆ apply_generic() [2/2]

result_t cadabra::Algorithm::apply_generic ( iterator ,
bool  deep,
bool  repeat,
unsigned int  depth 
)

◆ apply_once()

◆ apply_pre_order()

Algorithm::result_t Algorithm::apply_pre_order ( bool  repeat = false)

Apply algorithm with alternative traversal: starting from the top node, traverse the tree pre-order ('parent before child') and once the algorithm acts at a given node, do not traverse the subtree below anymore.

Definition at line 66 of file Algorithm.cc.

References apply_once(), tree< T, tree_node_allocator >::begin(), c_str(), cadabra::cleanup_dispatch_deep(), tree< T, tree_node_allocator >::end(), ProgressMonitor::group(), cadabra::Ex::is_hidden(), cadabra::IndexClassifier::kernel, pm, tr, and traverse_ldots.

◆ begin_index()

◆ can_apply()

◆ check_consistency()

bool Algorithm::check_consistency ( iterator  it) const

◆ check_degree_consistency()

bool Algorithm::check_degree_consistency ( iterator  ) const

Given an expression top node, check differential form degree consistency.

Definition at line 501 of file Algorithm.cc.

Referenced by cadabra::check_index_consistency().

◆ check_index_consistency()

bool Algorithm::check_index_consistency ( iterator  it) const

◆ compare_()

bool Algorithm::compare_ ( const str_node one,
const str_node two 
)
staticprotected

◆ contains()

bool Algorithm::contains ( sibling_iterator  from,
sibling_iterator  to,
sibling_iterator  arg 
)
protected

Definition at line 734 of file Algorithm.cc.

References arg::name.

Referenced by find_arg_superset().

◆ end_index()

◆ equal_without_numbers()

bool Algorithm::equal_without_numbers ( nset_t::iterator  it1,
nset_t::iterator  it2 
)
staticprotected

Definition at line 1091 of file Algorithm.cc.

◆ find_arg_superset() [1/2]

template<class Iter >
Algorithm::range_vector_t::iterator Algorithm::find_arg_superset ( range_vector_t ran,
Iter  st,
Iter  nd 
)
protected

Definition at line 767 of file Algorithm.cc.

References contains().

Referenced by find_arg_superset().

◆ find_arg_superset() [2/2]

Algorithm::range_vector_t::iterator Algorithm::find_arg_superset ( range_vector_t ran,
sibling_iterator  it 
)
protected

Definition at line 743 of file Algorithm.cc.

References find_arg_superset().

◆ find_argument_lists()

void cadabra::Algorithm::find_argument_lists ( range_vector_t ,
bool  only_comma_lists = true 
) const
protected

◆ force_node_wrap()

void Algorithm::force_node_wrap ( iterator it,
std::string  nm 
)
protected

Wrap a term in a product or sum in a node with indicated name, irrespective of its parent (it usually makes more sense to call the safer prod_wrap_single_term or sum_wrap_single_term above).

Definition at line 862 of file Algorithm.cc.

References cadabra::str_node::b_none, tree< T, tree_node_allocator >::insert(), cadabra::one(), tree< T, tree_node_allocator >::reparent(), and tr.

Referenced by cadabra::explicit_indices::apply(), cadabra::rewrite_indices::apply(), prod_wrap_single_term(), and sum_wrap_single_term().

◆ index_parity()

int Algorithm::index_parity ( iterator  it) const
protected

◆ intersection_number()

template<class BinaryPredicate >
unsigned int Algorithm::intersection_number ( sibling_iterator  from1,
sibling_iterator  to1,
sibling_iterator  from2,
sibling_iterator  to2,
BinaryPredicate  fun 
) const
protected

Determine the number of elements in the first range which also occur in the second range.

Definition at line 250 of file Algorithm.hh.

References fun().

◆ is_factorlike()

bool Algorithm::is_factorlike ( iterator  it)
protected

Determines whether the indicated node is 'like a factor in a product'. This requires that the parent is a ‘\prod’ node.

Definition at line 800 of file Algorithm.cc.

References tree< T, tree_node_allocator >::is_valid(), tree< T, tree_node_allocator >::parent(), and tr.

Referenced by is_termlike().

◆ is_nonprod_factor_in_prod()

bool Algorithm::is_nonprod_factor_in_prod ( iterator  it)
protected

◆ is_single_term()

◆ is_termlike()

bool Algorithm::is_termlike ( iterator  it)
protected

Determines whether the indicated node is 'like a term in a sum'. This requires that the node is not a \sum node, not a child of a \prod node, and that its parent rel is of argument-type (p_none).

Definition at line 788 of file Algorithm.cc.

References is_factorlike(), and cadabra::str_node::p_none.

Referenced by cadabra::explicit_indices::apply(), cadabra::vary::apply(), and cadabra::explicit_indices::can_apply().

◆ less_without_numbers()

bool Algorithm::less_without_numbers ( nset_t::iterator  it1,
nset_t::iterator  it2 
)
staticprotected

Definition at line 1070 of file Algorithm.cc.

◆ locate_object_set()

bool Algorithm::locate_object_set ( const Ex objs,
Ex::iterator  st,
Ex::iterator  nd,
std::vector< unsigned int > &  store 
)
protected

◆ locate_single_object()

unsigned int Algorithm::locate_single_object ( Ex::iterator  obj_to_find,
Ex::iterator  st,
Ex::iterator  nd,
std::vector< unsigned int > &  store 
)
protected

Definition at line 986 of file Algorithm.cc.

References compare_(), tree< T, tree_node_allocator >::equal(), and tr.

Referenced by locate_object_set().

◆ node_integer()

void Algorithm::node_integer ( iterator  it,
int  num 
)
protected

◆ node_one()

◆ node_zero()

◆ number_of_direct_indices()

◆ number_of_indices() [1/2]

unsigned int Algorithm::number_of_indices ( const Properties pr,
iterator  it 
)
static

◆ number_of_indices() [2/2]

◆ prod_unwrap_single_term()

◆ prod_wrap_single_term()

◆ propagate_zeroes()

void Algorithm::propagate_zeroes ( post_order_iterator it,
const iterator topnode 
)
private

Given a node with zero multiplier, propagate this zero upwards in the tree. Changes the iterator so that it points to the next node in a post_order traversal (post_order: children first, then node). The second node is the topmost node, beyond which this routine is not allowed to touch the tree (i.e. the 2nd iterator will always remain valid).

Definition at line 310 of file Algorithm.cc.

References tree< T, tree_node_allocator >::begin(), tree< T, tree_node_allocator >::end(), tree< T, tree_node_allocator >::erase(), tree< T, tree_node_allocator >::flatten(), cadabra::Properties::get(), tree< T, tree_node_allocator >::index(), tree< T, tree_node_allocator >::insert_after(), tree< T, tree_node_allocator >::is_valid(), cadabra::IndexClassifier::kernel, cadabra::multiply(), tree< T, tree_node_allocator >::next_sibling(), node_one(), tree< T, tree_node_allocator >::number_of_children(), cadabra::one(), tree< T, tree_node_allocator >::parent(), cadabra::Kernel::properties, cadabra::rat_set, tr, and cadabra::zero().

Referenced by apply_deep().

◆ pushup_multiplier()

◆ rename_replacement_dummies()

◆ report_progress()

void Algorithm::report_progress ( const std::string &  ,
int  todo,
int  done,
int  count = 2 
)

◆ separated_by_derivative()

bool Algorithm::separated_by_derivative ( iterator  i1,
iterator  i2,
iterator  check_dependence 
) const
protected

Figure out whether two objects (commonly indices) are separated by a derivative operator, as in

\[ \partial_{a}{A_{b}} C^{b} \]

. If the last iterator is pointing to a valid node, check whether it is independent of the derivative (using the Depends property).

Definition at line 907 of file Algorithm.cc.

References tree< T, tree_node_allocator >::begin(), cadabra::DependsBase::dependencies(), tree< T, tree_node_allocator >::end(), cadabra::Properties::get(), cadabra::Properties::get_composite(), tree< T, tree_node_allocator >::is_valid(), cadabra::IndexClassifier::kernel, tree< T, tree_node_allocator >::lowest_common_ancestor(), tree< str_node >::parent(), cadabra::Kernel::properties, cadabra::subtree_exact_equal(), and tr.

Referenced by cadabra::canonicalise::apply(), and cadabra::eliminate_converter::handle_one_index().

◆ set_progress_monitor()

void Algorithm::set_progress_monitor ( ProgressMonitor pm_)

Provide the algorithm with a ProgressMonitor object on which to register (nested) progress information, to be reported out-of-band to a client.

Definition at line 61 of file Algorithm.cc.

References pm.

Referenced by cadabra::evaluate::simplify_components().

◆ sum_unwrap_single_term()

◆ sum_wrap_single_term()

bool Algorithm::sum_wrap_single_term ( iterator it)
protected

Definition at line 853 of file Algorithm.cc.

References force_node_wrap(), and is_single_term().

Member Data Documentation

◆ discard_command_node

bool cadabra::Algorithm::discard_command_node

Definition at line 104 of file Algorithm.hh.

◆ get_dummy_sw

Stopwatch cadabra::Algorithm::get_dummy_sw
mutable

Definition at line 115 of file Algorithm.hh.

◆ index_sw

Stopwatch cadabra::Algorithm::index_sw
mutable

Definition at line 114 of file Algorithm.hh.

◆ interrupted

bool cadabra::Algorithm::interrupted

◆ number_of_calls

unsigned int cadabra::Algorithm::number_of_calls

Definition at line 101 of file Algorithm.hh.

◆ number_of_modifications

unsigned int cadabra::Algorithm::number_of_modifications

Definition at line 102 of file Algorithm.hh.

◆ pm

ProgressMonitor* cadabra::Algorithm::pm
protected

◆ report_progress_stopwatch

Stopwatch cadabra::Algorithm::report_progress_stopwatch
mutable

Definition at line 116 of file Algorithm.hh.

Referenced by report_progress().

◆ suppress_normal_output

bool cadabra::Algorithm::suppress_normal_output

Definition at line 103 of file Algorithm.hh.

◆ tr

Ex& cadabra::Algorithm::tr
protected

Definition at line 136 of file Algorithm.hh.

Referenced by cadabra::join_gamma::append_prod_(), cadabra::young_reduce::apply(), cadabra::unwrap::apply(), cadabra::flatten_sum::apply(), cadabra::product_rule::apply(), cadabra::indexsort::apply(), cadabra::expand_delta::apply(), cadabra::sort_sum::apply(), cadabra::take_match::apply(), cadabra::expand_diracbar::apply(), cadabra::expand_power::apply(), cadabra::untrace::apply(), cadabra::unzoom::apply(), cadabra::expand::apply(), cadabra::explicit_indices::apply(), cadabra::young_project_product::apply(), cadabra::zoom::apply(), cadabra::combine::apply(), cadabra::decompose::apply(), cadabra::eliminate_kronecker::apply(), cadabra::flatten_product::apply(), cadabra::join_gamma::apply(), cadabra::keep_terms::apply(), cadabra::lower_free_indices::apply(), cadabra::order::apply(), cadabra::reduce_delta::apply(), cadabra::rename_dummies::apply(), cadabra::replace_match::apply(), cadabra::rewrite_indices::apply(), cadabra::sort_product::apply(), cadabra::sort_spinors::apply(), cadabra::split_gamma::apply(), cadabra::tabdimension::apply(), cadabra::young_project_tensor::apply(), cadabra::eliminate_converter::apply(), cadabra::epsilon_to_delta::apply(), cadabra::split_index::apply(), cadabra::young_project::apply(), cadabra::factor_in::apply(), cadabra::factor_out::apply(), cadabra::einsteinify::apply(), cadabra::fierz::apply(), cadabra::canonicalise::apply(), cadabra::collect_terms::apply(), cadabra::collect_components::apply(), cadabra::collect_factors::apply(), cadabra::vary::apply(), cadabra::complete::apply(), cadabra::decompose_product::apply(), cadabra::distribute::apply(), cadabra::integrate_by_parts::apply(), cadabra::map_mma::apply(), cadabra::map_sympy::apply(), cadabra::simplify::apply(), cadabra::substitute::apply(), cadabra::evaluate::apply(), apply_deep(), apply_generic(), apply_once(), apply_pre_order(), cadabra::factor_in::calc_restricted_hash(), cadabra::flatten_sum::can_apply(), cadabra::product_rule::can_apply(), cadabra::lr_tensor::can_apply(), cadabra::sym::can_apply(), cadabra::expand::can_apply(), cadabra::explicit_indices::can_apply(), cadabra::untrace::can_apply(), cadabra::expand_power::can_apply(), cadabra::expand_diracbar::can_apply(), cadabra::zoom::can_apply(), cadabra::flatten_product::can_apply(), cadabra::take_match::can_apply(), cadabra::expand_delta::can_apply(), cadabra::join_gamma::can_apply(), cadabra::reduce_delta::can_apply(), cadabra::replace_match::can_apply(), cadabra::rewrite_indices::can_apply(), cadabra::sort_product::can_apply(), cadabra::sort_spinors::can_apply(), cadabra::split_gamma::can_apply(), cadabra::epsilon_to_delta::can_apply(), cadabra::split_index::can_apply(), cadabra::factor_in::can_apply(), cadabra::fierz::can_apply(), cadabra::drop_keep_weight::can_apply(), cadabra::canonicalise::can_apply(), cadabra::collect_components::can_apply(), cadabra::collect_terms::can_apply(), cadabra::vary::can_apply(), cadabra::distribute::can_apply(), cadabra::map_mma::can_apply(), cadabra::map_sympy::can_apply(), cadabra::decompose_product::can_apply(), cadabra::simplify::can_apply(), cadabra::substitute::can_apply(), cadabra::evaluate::can_apply(), check_consistency(), cadabra::young_reduce::cleanup(), cadabra::evaluate::cleanup_components(), cadabra::factor_in::compare_prod_nonprod(), cadabra::factor_in::compare_restricted(), cadabra::evaluate::dense_factor(), cadabra::evaluate::dependencies(), cadabra::integrate_by_parts::derivative_acting_on_arg(), cadabra::drop_keep_weight::do_apply(), cadabra::lr_tensor::do_filledtableau(), cadabra::lr_tensor::do_tableau(), cadabra::sym::doit(), cadabra::fierz::fierz(), cadabra::collect_factors::fill_hash_map(), cadabra::collect_terms::fill_hash_map(), cadabra::factor_in::fill_hash_map(), force_node_wrap(), cadabra::evaluate::handle_components(), cadabra::evaluate::handle_derivative(), cadabra::evaluate::handle_epsilon(), cadabra::explicit_indices::handle_factor(), cadabra::evaluate::handle_factor(), cadabra::eliminate_converter::handle_one_index(), cadabra::evaluate::handle_prod(), cadabra::evaluate::handle_sum(), cadabra::integrate_by_parts::handle_term(), index_parity(), cadabra::evaluate::is_component(), is_factorlike(), is_nonprod_factor_in_prod(), is_single_term(), locate_object_set(), locate_single_object(), cadabra::evaluate::merge_component_children(), cadabra::evaluate::merge_components(), node_integer(), node_one(), node_zero(), cadabra::young_project::nth_index_node(), cadabra::reduce_delta::one_step_(), cadabra::canonicalise::only_one_on_derivative(), cadabra::young_reduce::permute(), prod_unwrap_single_term(), cadabra::decompose_product::project_onto_initial_symmetries(), propagate_zeroes(), pushup_multiplier(), cadabra::young_reduce::reduce(), cadabra::join_gamma::regroup_indices_(), cadabra::canonicalise::remove_traceless_traces(), cadabra::canonicalise::remove_vanishing_numericals(), cadabra::collect_terms::remove_zeroed_terms(), rename_replacement_dummies(), separated_by_derivative(), cadabra::evaluate::simplify_components(), cadabra::integrate_by_parts::split_off_single_derivative(), cadabra::substitute::substitute(), sum_unwrap_single_term(), cadabra::tab_basics::tabs_to_singlet_rules(), cadabra::tab_basics::tabs_to_tree(), cadabra::tab_basics::tree_to_numerical_tab(), cadabra::evaluate::unwrap_scalar_in_components_node(), and cadabra::evaluate::wrap_scalar_in_components_node().

◆ traverse_ldots

bool cadabra::Algorithm::traverse_ldots
protected

Definition at line 227 of file Algorithm.hh.

Referenced by apply_deep(), apply_once(), apply_pre_order(), and cadabra::unzoom::unzoom().


The documentation for this class was generated from the following files: