Math::Symbolic::OperatUser)Contributed Perl DocumenMath::Symbolic::Operator(3)NAMEMath::Symbolic::Operator - Operators in symbolic calculations
SYNOPSIS
use Math::Symbolic::Operator;
my $sum = Math::Symbolic::Operator->new('+', $term1, $term2);
# or:
my $division =
Math::Symbolic::Operator->new(
{
type => B_DIVISON,
operands => [$term1, $term2],
}
);
my $derivative =
Math::Symbolic::Operator->new(
{
type => U_P_DERIVATIVE,
operands => [$term],
}
);
DESCRIPTION
This module implements all Math::Symbolic::Operator objects. These
objects are overloaded in stringification-context to call the
to_string() method on the object. In numeric and boolean context, they
evaluate to their numerical representation.
For a list of supported operators, please refer to the list found
below, in the documentation for the new() constructor.
Math::Symbolic::Operator inherits from Math::Symbolic::Base.
EXPORT
None.
CLASS DATAMath::Symbolic::Operator contains several class data structures.
Usually, you should not worry about dealing with any of them because
they are mostly an implementation detail, but for the sake of
completeness, here's the gist, but feel free to skip this section of
the docs:
One of these is the %Op_Symbols hash that associates operator (and
function) symbols with the corresponding constant as exported by
Math::Symbolic or Math::Symbolic::ExportConstants. (For example, '+' =>
B_SUM which in turn is 0, if I recall correctly. But I didn't tell you
that. Because you're supposed to use the supplied (inlined and hence
fast) constants so I can change their internal order if I deem it
necessary.)
The array @Op_Types associates operator indices (recall those nifty
constants?) with anonymous hash datastructures that contain some info
on the operator such as its arity, the rule used to derive it, its
infix string, its prefix string, and information on how to actually
apply it to numbers.
METHODS
Constructor new
Expects a hash reference as first argument. That hash's contents will
be treated as key-value pairs of object attributes. Important
attributes are 'type' => OPERATORTYPE (use constants as exported by
Math::Symbolic::ExportConstants!) and 'operands=>[op1,op2,...]'. Where
the operands themselves may either be valid Math::Symbolic::* objects
or strings that will be parsed as such.
Special case: if no hash reference was found, first argument is assumed
to be the operator's symbol and the operator is assumed to be binary.
The following 2 arguments will be treated as operands. This special
case will ignore attempts to clone objects but if the operands are no
valid Math::Symbolic::* objects, they will be sent through a
Math::Symbolic::Parser to construct Math::Symbolic trees.
Returns a Math::Symbolic::Operator.
Supported operator symbols: (number of operands and their function in
parens)
+ => sum (2)
- => difference (2)
* => product (2)
/ => division (2)
log => logarithm (2: base, function)
^ => exponentiation (2: base, exponent)
neg => unary minus (1)
partial_derivative => partial derivative (2: function, var)
total_derivative => total derivative (2: function, var)
sin => sine (1)
cos => cosine (1)
tan => tangent (1)
cot => cotangent (1)
asin => arc sine (1)
acos => arc cosine (1)
atan => arc tangent (1)
atan2 => arc tangent of y/x (2: y, x)
acot => arc cotangent (1)
sinh => hyperbolic sine (1)
cosh => hyperbolic cosine (1)
asinh => hyperbolic area sine (1)
acosh => hyperbolic area cosine (1)
Method arity
Returns the operator's arity as an integer.
Method type
Optional integer argument that sets the operator's type. Returns the
operator's type as an integer.
Method to_string
Returns a string representation of the operator and its operands.
Optional argument: 'prefix' or 'infix'. Defaults to 'infix'.
Method term_type
Returns the type of the term. ( T_OPERATOR )
Method simplify
Term simpilification. First argument: Boolean indicating that the tree
does not need to be cloned, but can be restructured instead. While
this is faster, you might not be able to use the old tree any more.
Example:
my $othertree = $tree->simplify();
# can use $othertree and $tree now.
my $yetanothertree = $tree->simplify(1);
# must not use $tree any more because its internal
# representation might have been destroyed.
If you want to optimize a routine and you're sure that you won't need
the unsimplified tree any more, go ahead and use the first parameter.
In all other cases, you should go the safe route.
Methods op1 and op2
Returns first/second operand of the operator if it exists or undef.
Method apply
Applies the operation to its operands' value() and returns the result
as a constant (-object).
Without arguments, all variables in the tree are required to have a
value. If any don't, the call to apply() returns undef.
To (temorarily, for this single method call) assign values to variables
in the tree, you may provide key/value pairs of variable names and
values. Instead of passing a list of key/value pairs, you may also pass
a single hash reference containing the variable mappings.
You usually want to call the value() instead of this.
Method value
value() evaluates the Math::Symbolic tree to its numeric
representation.
value() without arguments requires that every variable in the tree
contains a defined value attribute. Please note that this refers to
every variable object, not just every named variable.
value() with one argument sets the object's value if you're dealing
with Variables or Constants. In case of operators, a call with one
argument will assume that the argument is a hash reference. (see next
paragraph)
value() with named arguments (key/value pairs) associates variables in
the tree with the value-arguments if the corresponging key matches the
variable name. (Can one say this any more complicated?) Since version
0.132, an equivalent and valid syntax is to pass a single hash
reference instead of a list.
Example: $tree->value(x => 1, y => 2, z => 3, t => 0) assigns the value
1 to any occurrances of variables of the name "x", aso.
If a variable in the tree has no value set (and no argument of value
sets it temporarily), the call to value() returns undef.
Method signature
signature() returns a tree's signature.
In the context of Math::Symbolic, signatures are the list of variables
any given tree depends on. That means the tree "v*t+x" depends on the
variables v, t, and x. Thus, applying signature() on the tree that
would be parsed from above example yields the sorted list ('t', 'v',
'x').
Constants do not depend on any variables and therefore return the empty
list. Obviously, operators' dependencies vary.
Math::Symbolic::Variable objects, however, may have a slightly more
involved signature. By convention, Math::Symbolic variables depend on
themselves. That means their signature contains their own name. But
they can also depend on various other variables because variables
themselves can be viewed as placeholders for more compicated terms. For
example in mechanics, the acceleration of a particle depends on its
mass and the sum of all forces acting on it. So the variable
'acceleration' would have the signature ('acceleration', 'force1',
'force2',..., 'mass', 'time').
If you're just looking for a list of the names of all variables in the
tree, you should use the explicit_signature() method instead.
Method explicit_signature
explicit_signature() returns a lexicographically sorted list of
variable names in the tree.
See also: signature().
AUTHOR
Please send feedback, bug reports, and support requests to the
Math::Symbolic support mailing list: math-symbolic-support at lists dot
sourceforge dot net. Please consider letting us know how you use
Math::Symbolic. Thank you.
If you're interested in helping with the development or extending the
module's functionality, please contact the developers' mailing list:
math-symbolic-develop at lists dot sourceforge dot net.
List of contributors:
Steffen MA~Xller, symbolic-module at steffen-mueller dot net
Stray Toaster, mwk at users dot sourceforge dot net
Oliver EbenhA~Xh
SEE ALSO
New versions of this module can be found on http://steffen-mueller.net
or CPAN. The module development takes place on Sourceforge at
http://sourceforge.net/projects/math-symbolic/
Math::Symbolic
perl v5.14.1 2011-07-26 Math::Symbolic::Operator(3)
