- COPYRIGHT & LICENSE
Acme::AlgebraicToRPN - convert algebraic notation to sane RPN
$rpn = Acme::AlgebraicToRPN->new; @RPN = $rpn->eval($equation);
Given a string with algebraic notation, convert to RPN, which is what any crappy dime store calculator needs to do anyway.
Doesn't really process anything, that's up to you. You will get an array back with all of the variables and operations in RPN format. So that 3+4 will come back as
3 4 add
Possible future extensions will be to allow you to actually process this via hooks that allow specifications of how to handle foreign functions. But for my purposes, the array is good enough, as I am passing this on to a C program to do some serious number crunching.
Additionally, you can specify (via the constructor) the names of your own functions. See below.
The Hewlett Packard Company and the HP 35, my first real calculator, and Steffen Mueller for the Math::Symbolic code.
<cramps.the at gmail.com>
Please report any bugs or feature requests to
bug-acme-algebraictorpn at rt.cpan.org, or through the web interface at http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Acme-AlgebraicToRPN. I will be notified, and then you'll automatically be notified of progress on your bug as I make changes.
You can find documentation for this module with the perldoc command.
You can also look for information at:
AnnoCPAN: Annotated CPAN documentation
RT: CPAN's request tracker
Copyright 2009 X Cramps, all rights reserved.
This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
$al = Acme::AlgebraicToRPN->new(%opts);
%opts (optional) can be:
userFunc - user functions, as array reference
If you had a user function box and fft, you'd need to specify them like this:
$al = Acme::AlgebraicToRPN->new(userFunc => [qw(box fft)]);
@stack = $al->rpn($expr);
Processes $expr (an algebraic format expression) and return the stack necessary to process it. The stack consists entirely of variables, constants and operations. For operations, be prepared to handle (and others, see Math::Symbolic documentation):
negate add subtract multiply divide exponentiate sin cos tan cot asin acos atan atan2 acot sinh cosh asinh acosh
Plus any that you may add in constructor .
undef is returned if the parens don't balance. That's all the checking we do.
 If you supply a custom function, you can supply arguments to it. When you see your function name on the returned stack, the next thing on the stack is the I<number> of arguments, and then the arguments themselves. For example, let's say you registered your function 'foo' (in constructor) and you gave B<rpn> this equation: 4*foo(a,3) You'd get back this: 4 a 3 2 foo multiply
$stack = $al->rpn($expr);
Same as rpn, but returns as a comma-separated list. Split on commas, and you have your stack to be processed.
$ok = $al->check(\@stack, @expected);
Checks result of RPN conversion. @stack is what the rpn function returned, and @expected is what you expected the result to be. This is kind of a diagnostic routine for testing.
Returns 1 if both @stack and @expected were the same, 0 if not.