1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
/*
Cadabra: a field-theory motivated computer algebra system.
Copyright (C) 2001-2014 Kasper Peeters <kasper.peeters@phi-sci.com>
This program is free software: you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "Storage.hh"
#include "Kernel.hh"
namespace cadabra {
typedef void (*dispatcher_t)(const Kernel& k, Ex&, Ex::iterator& it);
/// \ingroup cleanup
///
/// Central cleanup dispatch routine, which calls the other cleanup
/// functions defined later.
///
/// These cleanup routines do NOT use normal cadabra algorithms; they
/// are completely independent of them to prevent circular dependence
/// or infinite recursion.
///
/// 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, UNLESS that would leave the tree in an inconsistent
/// state. An example is acting at the top node of
/// `\prod{4}{\sum{a}{b}}`, which would push the 4 to the multiplier of
/// the sum, but that is not allowed, so it needs to go further down.
/// Sibling nodes of 'it' remain untouched as well.
void cleanup_dispatch(const Kernel& k, Ex&, Ex::iterator& it);
/// \ingroup cleanup
///
/// More general cleanup of an entire tree. Walks depth-first along the
/// entire tree and call cleanup_dispatch at every node.
void cleanup_dispatch_deep(const Kernel& k, Ex&, dispatcher_t disp=&cleanup_dispatch);
void cleanup_dispatch_deep(const Kernel& k, Ex&, Ex::iterator& it, dispatcher_t disp=&cleanup_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).
bool cleanup_fraclike(const Kernel& k, Ex&, Ex::iterator& it);
bool cleanup_powlike(const Kernel& k, Ex&, Ex::iterator& it);
bool cleanup_productlike(const Kernel& k, Ex&, Ex::iterator& it);
bool cleanup_sumlike(const Kernel& k, Ex&, Ex::iterator& it);
bool cleanup_derivative(const Kernel& k, Ex&, Ex::iterator& it);
bool cleanup_partialderivative(const Kernel& k, Ex&, Ex::iterator& it);
bool cleanup_components(const Kernel& k, Ex&, Ex::iterator& it);
bool cleanup_numericalflat(const Kernel& k, Ex&, Ex::iterator& it);
bool cleanup_diagonal(const Kernel& k, Ex&, Ex::iterator& it);
bool cleanup_kronecker(const Kernel& k, Ex&, Ex::iterator& it);
bool cleanup_exterior_derivative(const Kernel& k, Ex&, Ex::iterator& it);
bool cleanup_comma(const Kernel&k, Ex&, Ex::iterator& it);
bool cleanup_tie(const Kernel&k, Ex&, 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).
bool push_down_multiplier(const Kernel& k, Ex& tr, Ex::iterator it);
/// Generic tool to check for index inconsistencies independent of
/// running any algorithm.
void check_index_consistency(const Kernel& k, Ex& tr, Ex::iterator it);
}
|
