|
| virtual | ~Variable ()=default |
| std::size_t | HashImpl () const override |
| | Compute this node's structural hash.
|
| bool | IsSame (Node const &other) const override |
| | Order-sensitive structural equality, shallow given interned children.
|
| | operator std::string () |
| | Convert to the variable's name string.
|
| std::shared_ptr< Node > | Differentiate (std::shared_ptr< Variable > const &v=nullptr) const override |
| | Differentiates a variable.
|
| std::shared_ptr< Node > | Subs (SubstitutionMap const &substitutions) const override |
| | Substitutes this variable: if its name is a key in substitutions, returns the associated replacement node; otherwise returns this variable unchanged.
|
| int | Degree (std::shared_ptr< Variable > const &v=nullptr) const override |
| | Compute the degree with respect to a single variable.
|
| int | Degree (VariableGroup const &vars) const override |
| | Compute the overall degree with respect to a variable group.
|
| std::vector< int > | MultiDegreeImpl (VariableGroup const &vars) const override |
| | Per-node-type multidegree.
|
| bool | IsHomogeneous (std::shared_ptr< Variable > const &v=nullptr) const override |
| | Check for homogeneity, absolutely with respect to all variables, including path variables and all other variable types, or with respect to a single varaible, if passed.
|
| bool | IsHomogeneous (VariableGroup const &vars) const override |
| | Check for homogeneity, with respect to a variable group.
|
| const std::string & | name () const |
| | Get the name of the named symbol.
|
| void | name (const std::string &new_name) |
| | Get the name of the named symbol.
|
| void | print (std::ostream &target) const override |
| | Virtual method for printing Nodes to arbitrary output streams.
|
| virtual std::shared_ptr< Node > | Simplified () const |
| | Functionally simplify this tree, returning a NEW simplified tree.
|
| virtual unsigned | Precedence () const |
| | The printing precedence of this node, deciding parenthesization.
|
| virtual bool | IsLiteralZero () const |
| | Is this node the literal constant 0?
|
| virtual bool | IsLiteralOne () const |
| | Is this node the literal constant 1?
|
| std::size_t | Hash () const |
| | Memoized structural hash of this node.
|
| std::shared_ptr< const void > | EvalProgram () const |
| | Opaque, lazily-populated cache of a compiled evaluator for this expression.
|
| void | SetEvalProgram (std::shared_ptr< const void > p) const |
| | Stash a compiled evaluator for this expression (type-erased; see EvalProgram()).
|
| std::shared_ptr< Node > | Differentiate (std::shared_ptr< Variable > const &v, unsigned count) const |
| | Differentiate repeatedly with respect to a single variable.
|
| std::shared_ptr< Node > | Differentiate (VariableGroup const &vars) const |
| | Differentiate with respect to each variable in a group, in sequence.
|
| std::vector< int > | MultiDegree (VariableGroup const &vars) const |
| | Compute the multidegree with respect to a variable group.
|
| virtual std::shared_ptr< Node > | Homogenized (VariableGroup const &vars, std::shared_ptr< Variable > const &homvar) const |
| | Homogenize a tree, returning a NEW homogenized tree (functional / non-mutating).
|
| bool | IsPolynomial (std::shared_ptr< Variable > const &v=nullptr) const |
| | Check if a Node is polynomial – it has degree at least 0.
|
| bool | IsPolynomial (VariableGroup const &v) const |
| | Check if a Node is polynomial – it has degree at least 0.
|
| virtual VisitReturnType | Accept (VisitorBase &)=0 |
| | Accept a visitor (dispatch to the visitor's Visit for this concrete type).
|
Represents variable leaves in the function tree.
This class represents variable leaves in the function tree.
When differentiated, produces a differential referring to it.
| std::shared_ptr< const void > bertini::node::Node::EvalProgram |
( |
| ) |
const |
|
inlineinherited |
Opaque, lazily-populated cache of a compiled evaluator for this expression.
The system layer (EvalExpression / f.eval) compiles a StraightLineProgram for ([this], canonical-by-name variable order) on first use and stashes it here, so repeated evaluations of the same (hash-consed, immutable) expression reuse it — like the memoized Hash(). The type is erased because the SLP lives in the system layer, above function_tree; the compiled program holds no node pointers (its constants are value recipes, ADR-0027), so there is no reference cycle. Transient: not serialized; a clone recompiles on demand.
| virtual std::shared_ptr< Node > bertini::node::Node::Homogenized |
( |
VariableGroup const & | vars, |
|
|
std::shared_ptr< Variable > const & | homvar ) const |
|
virtualinherited |
Homogenize a tree, returning a NEW homogenized tree (functional / non-mutating).
Input a variable group holding the non-homogeneous variables, and the new homogenizing variable. The homvar may be an element of the variable group, that's perfectly ok.
The input tree is never modified; degree-deficient summands are padded with powers of homvar in a freshly-built tree (so a throw on a non-polynomial term can't leave a half-homogenized tree behind). The default (leaves, and anything with nothing to homogenize) returns the node unchanged.
- Parameters
-
| homvar | The homogenizing variable, which is multiplied against terms with degree deficiency with repect to other terms. |
| vars | A group of variables, with respect to which you wish to homogenize. |
- Returns
- A homogenized tree (possibly the same node, if nothing changed).
Reimplemented in bertini::node::ArcCosOperator, bertini::node::ArcSinOperator, bertini::node::ArcTanOperator, bertini::node::CosOperator, bertini::node::ExpOperator, bertini::node::IntegerPowerOperator, bertini::node::LogOperator, bertini::node::MultOperator, bertini::node::NamedExpression, bertini::node::NegateOperator, bertini::node::PowerOperator, bertini::node::SinOperator, bertini::node::SqrtOperator, bertini::node::SumOperator, and bertini::node::TanOperator.
| bool bertini::node::Variable::IsSame |
( |
Node const & | other | ) |
const |
|
inlineoverridevirtual |
Order-sensitive structural equality, shallow given interned children.
Two nodes are the same iff they have the same dynamic type, the same operator payload (signs / mult-or-div flags / integer exponent / literal value), and the same operands by pointer** (operands are not recursed – in the hash-consed world children are already canonical, so pointer-equality is structural equality). The default is node identity; value/operator nodes override. Consistent with Hash(): IsSame(a,b) implies a.Hash()==b.Hash().
Reimplemented from bertini::node::Node.
| std::vector< int > bertini::node::Node::MultiDegree |
( |
VariableGroup const & | vars | ) |
const |
|
inherited |
Compute the multidegree with respect to a variable group.
This is for homogenization, and testing for homogeneity.
- Returns
- A vector containing the degrees. Negative entries indicate non-polynomiality. Compute the multidegree with respect to a variable group.
DAG-AWARE: this is a non-virtual wrapper that memoizes by node identity FOR THE DURATION OF ONE TOP-LEVEL CALL, so a shared subtree is visited once however many times it is reached. The per-type work lives in MultiDegreeImpl.
Why it exists (b2#417): the node graph is hash-consed, so a small DAG can stand for an enormous expansion – measured, a 46-node expression whose printed form is 196 KB. A plain recursive walk visits the TREE, so it costs O(expansion) where the structure is O(DAG). CanonicalizeNaryOperands calls this for every operand of every n-ary construction, which is how a 46-node expression came to cost 13 ms to multiply by a variable, and how a cofactor expansion inside a deflation stage came to run for hours with a DAG that never exceeded 1102 nodes.
Caching the RESULT between calls does not fix this and was measured 29% SLOWER – filling such a cache costs the same walk it is trying to avoid, so it only pays from a node's second mention. The memo has to be inside the traversal, which is what this is.
| virtual std::shared_ptr< Node > bertini::node::Node::Simplified |
( |
| ) |
const |
|
virtualinherited |
Functionally simplify this tree, returning a NEW simplified tree.
Non-mutating successor to the in-place EliminateZeros / EliminateOnes / ReduceDepth machinery (ADR-0011, issue 251). The input tree is never modified; a fresh simplified tree is returned, built through the SimplifiedSum / SimplifiedMult / SimplifiedNegate factories so that literal zeros/ones vanish and exact constants fold. The default (leaves, and any node with nothing to simplify) returns the node unchanged – structural sharing preserved.
- Returns
- A simplified tree (possibly the same node, if nothing simplified).
Reimplemented in bertini::node::ArcCosOperator, bertini::node::ArcSinOperator, bertini::node::ArcTanOperator, bertini::node::CosOperator, bertini::node::ExpOperator, bertini::node::IntegerPowerOperator, bertini::node::LogOperator, bertini::node::MultOperator, bertini::node::NegateOperator, bertini::node::PowerOperator, bertini::node::SinOperator, bertini::node::SqrtOperator, bertini::node::SumOperator, and bertini::node::TanOperator.
1.15.0