anchor.diff:  
   parses_real_number_strings() ->
       [
  -     ?assertFloat("5", 5),
  -     ?assertFloat("42.1", 42.1),
  -     ?assertFloat("-2.0e-3", -0.002),
  -     ?assertFloat("6.02E23", 6.02e23)
  +     ?assertRPNFloat("5", 5),
  +     ?assertRPNFloat("42.1", 42.1),
  +     ?assertRPNFloat("-2.0e-3", -0.002),
  +     ?assertRPNFloat("6.02E23", 6.02e23)
       ].
   
   parses_complex_number_strings() ->
       [
  -     ?assertFloat("5,3", {5,3}),
  -     ?assertFloat("-2.0e-3,5", {-0.002,5}),
  -     ?assertFloat("4,-7.0e3", {4,-7.0e3}),
  -     ?assertFloat("-0.4,-0.75", {-0.4,-0.75})
  +     ?assertRPNFloat("5,3", {5,3}),
  +     ?assertRPNFloat("-2.0e-3,5", {-0.002,5}),
  +     ?assertRPNFloat("4,-7.0e3", {4,-7.0e3}),
  +     ?assertRPNFloat("-0.4,-0.75", {-0.4,-0.75})
       ].
   
   % Basic Arithmetic
   addition_tests() ->
       [
  -     ?assertFloat("1   2    +", 3),
  -     ?assertFloat("1   2,-2 +", {3,-2}),
  -     ?assertFloat("1,7 2    +", {3,7}),
  -     ?assertFloat("1,7 2,-2 +", {3,5})
  +     ?assertRPNFloat("1   2    +", 3),
  +     ?assertRPNFloat("1   2,-2 +", {3,-2}),
  +     ?assertRPNFloat("1,7 2    +", {3,7}),
  +     ?assertRPNFloat("1,7 2,-2 +", {3,5})
       ].
   
   subtraction_tests() ->
       [
  -     ?assertFloat("1   2    -", -1),
  -     ?assertFloat("1   2,-2 -", {-1,2}),
  -     ?assertFloat("1,7 2    -", {-1,7}),
  -     ?assertFloat("1,7 2,-2 -", {-1,9})
  +     ?assertRPNFloat("1   2    -", -1),
  +     ?assertRPNFloat("1   2,-2 -", {-1,2}),
  +     ?assertRPNFloat("1,7 2    -", {-1,7}),
  +     ?assertRPNFloat("1,7 2,-2 -", {-1,9})
       ].
   
   multiplication_tests() ->
       [
  -     ?assertFloat("2    4,3 *",  {8 ,6}),
  -     ?assertFloat("1,-2 3   *", {3 ,-6}),
  -     ?assertFloat("1,-2 4,3 *", {10,-5}),
  -     ?assertFloat("3.14 2   *",    6.28)
  +     ?assertRPNFloat("2    4,3 *",  {8 ,6}),
  +     ?assertRPNFloat("1,-2 3   *", {3 ,-6}),
  +     ?assertRPNFloat("1,-2 4,3 *", {10,-5}),
  +     ?assertRPNFloat("3.14 2   *",    6.28)
       ].
   
   division_tests() ->
       [
  -     ?assertFloat("3,2 2,4 /", {0.7,-0.4}),
  -     ?assertFloat("3,2 2   /",  {1.5,1.0}),
  -     ?assertFloat("3   2,4 /", {0.3,-0.6}),
  -     ?assertFloat("1   2   /",        0.5),
  +     ?assertRPNFloat("3,2 2,4 /", {0.7,-0.4}),
  +     ?assertRPNFloat("3,2 2   /",  {1.5,1.0}),
  +     ?assertRPNFloat("3   2,4 /", {0.3,-0.6}),
  +     ?assertRPNFloat("1   2   /",        0.5),
        ?assertRPNError("/", [0, 10]),
        ?assertRPNError("/", [{0,0}, 10])
       ].
   
   integer_division_tests() ->
       [
  -     ?assertFloat("45.4 7 div", 6),
  -     ?assertFloat("23 4 %", 3),
  +     ?assertRPNFloat("45.4 7 div", 6),
  +     ?assertRPNFloat("23 4 %", 3),
        ?assertRPNError("div", [0, 10]),
        ?assertRPNError("%", [0, 10])
       ].
   
   raises_a_number_to_a_power() ->
       [
  -     ?assertFloat("2 5 **",      32.0),
  -     ?assertFloat("2 3,4 **",    {-7.461496614688569,2.8854927255134477}),
  -     ?assertFloat("3,4 2.5 **",  {-37.999999999999986,41.000000000000014}),
  -     ?assertFloat("1,2 3,-2 **", {-14.405859669065997,101.33689785344499}),
  -     ?assertFloat("i i **",      {0.20787957635,0})
  +     ?assertRPNFloat("2 5 **",      32.0),
  +     ?assertRPNFloat("2 3,4 **",    {-7.461496614688569,2.8854927255134477}),
  +     ?assertRPNFloat("3,4 2.5 **",  {-37.999999999999986,41.000000000000014}),
  +     ?assertRPNFloat("1,2 3,-2 **", {-14.405859669065997,101.33689785344499}),
  +     ?assertRPNFloat("i i **",      {0.20787957635,0})
       ].
   
   change_sign() ->
       [
  -     ?assertFloat("12 chs",   -12),
  -     ?assertFloat("4,-2 chs", {-4,2})
  +     ?assertRPNFloat("12 chs",   -12),
  +     ?assertRPNFloat("4,-2 chs", {-4,2})
       ].
   
   absolute_value() ->
       [
  -     ?assertFloat("-5 abs",    5),
  -     ?assertFloat("3.14 abs",  3.14),
  -     ?assertFloat("5,-12 abs", 13.0)
  +     ?assertRPNFloat("-5 abs",    5),
  +     ?assertRPNFloat("3.14 abs",  3.14),
  +     ?assertRPNFloat("5,-12 abs", 13.0)
       ].
   
   argument_of_complex_number() ->
       [
  -     ?assertFloat("-1,-1 arg", -3*math:pi()/4),
  -     ?assertFloat("0,-1 arg", -math:pi()/2),
  -     ?assertFloat("1,-1 arg", -math:pi()/4),
  -     ?assertFloat("1,0 arg", 0.0),
  -     ?assertFloat("1,1 arg", math:pi()/4),
  -     ?assertFloat("0,1 arg", math:pi()/2),
  -     ?assertFloat("-1,1 arg", 3*math:pi()/4),
  -     ?assertFloat("-1,0 arg", math:pi()),
  +     ?assertRPNFloat("-1,-1 arg", -3*math:pi()/4),
  +     ?assertRPNFloat("0,-1 arg", -math:pi()/2),
  +     ?assertRPNFloat("1,-1 arg", -math:pi()/4),
  +     ?assertRPNFloat("1,0 arg", 0.0),
  +     ?assertRPNFloat("1,1 arg", math:pi()/4),
  +     ?assertRPNFloat("0,1 arg", math:pi()/2),
  +     ?assertRPNFloat("-1,1 arg", 3*math:pi()/4),
  +     ?assertRPNFloat("-1,0 arg", math:pi()),
        ?assertRPNError("arg", [{0,0}]),
        ?assertRPNError("arg", [42])
       ].
   
   constants() ->
       [
  -     ?assertFloat("pi", 3.141592653589793),
  -     ?assertFloat("e", 2.718281828459045),
  -     ?assertFloat("phi", 1.618033988749895),
  -     ?assertFloat("i", {0,1})
  +     ?assertRPNFloat("pi", 3.141592653589793),
  +     ?assertRPNFloat("e", 2.718281828459045),
  +     ?assertRPNFloat("phi", 1.618033988749895),
  +     ?assertRPNFloat("i", {0,1})
       ].
   
   % Trigonometric
   trig_functions_in_real_domain() ->
       [
  -     ?assertFloat("30 sin", 0.5),
  -     ?assertFloat("60 cos", 0.5),
  -     ?assertFloat("45 tan", 1.0),
  -     ?assertFloat("0.5 asin", 30.0),
  -     ?assertFloat("0.5 acos", 60.0),
  -     ?assertFloat("1 atan", 45.0),
  +     ?assertRPNFloat("30 sin", 0.5),
  +     ?assertRPNFloat("60 cos", 0.5),
  +     ?assertRPNFloat("45 tan", 1.0),
  +     ?assertRPNFloat("0.5 asin", 30.0),
  +     ?assertRPNFloat("0.5 acos", 60.0),
  +     ?assertRPNFloat("1 atan", 45.0),
        ?assertRPNError("asin", [10]),
        ?assertRPNError("acos", [-10])
       ].
   
   trig_functions_in_complex_domain() ->
       [
  -     ?assertFloat("1,1 sin", {1.298457581,0.634963915}),
  -     ?assertFloat("1,1 cos", {0.833730025,-0.988897706}),
  -     ?assertFloat("1,1 tan", {0.271752585,1.083923327})
  +     ?assertRPNFloat("1,1 sin", {1.298457581,0.634963915}),
  +     ?assertRPNFloat("1,1 cos", {0.833730025,-0.988897706}),
  +     ?assertRPNFloat("1,1 tan", {0.271752585,1.083923327})
        % ,
  -     % ?assertFloat("1,1 asin", {0.666239432,1.061275062}),
  -     % ?assertFloat("1,1 acos", {0.904556894,1.061275062}),
  -     % ?assertFloat("1,1 atan", {1.017221968,0.402359478})
  +     % ?assertRPNFloat("1,1 asin", {0.666239432,1.061275062}),
  +     % ?assertRPNFloat("1,1 acos", {0.904556894,1.061275062}),
  +     % ?assertRPNFloat("1,1 atan", {1.017221968,0.402359478})
       ].
   
   % Hyperbolic Trigonometry
   hyperbolic_trig_functions_in_real_domaion() ->
       [
  -     ?assertFloat("2 sinh", 3.6268604079),
  -     ?assertFloat("4 cosh", 27.308232836),
  -     ?assertFloat("-0.5 tanh", -0.462117157),
  -     ?assertFloat("3.6268604079 asinh", 2.0),
  -     ?assertFloat("27.30823284 acosh", 4.0),
  -     ?assertFloat("-0.462117157 atanh", -0.5),
  +     ?assertRPNFloat("2 sinh", 3.6268604079),
  +     ?assertRPNFloat("4 cosh", 27.308232836),
  +     ?assertRPNFloat("-0.5 tanh", -0.462117157),
  +     ?assertRPNFloat("3.6268604079 asinh", 2.0),
  +     ?assertRPNFloat("27.30823284 acosh", 4.0),
  +     ?assertRPNFloat("-0.462117157 atanh", -0.5),
        ?assertRPNError("acosh", [0]),
        ?assertRPNError("atanh", [1]),
        ?assertRPNError("atanh", [-1]),
  
positive.code: 
  hyperbolic_trig_functions_in_complex_domain() ->
      [
       ?assertFloat("1,1 sinh", {0.634963915,1.298457581}),
       ?assertFloat("1,1 cosh", {0.833730025,0.988897706}),
       ?assertFloat("1,1 tanh", {1.083923327,0.271752585})
      ].
  
  % Powers and Logarithms
  powers_and_logarithms_tests() ->
      [
       ?assertFloat("64 sqrt", 8.0),
       ?assertFloat("2,3 \\", {2/13, -3/13}),
       ?assertRPNError("\\", [0]),
       ?assertRPNError("\\", [0]),
       ?assertFloat("10 exp", 22026.465794807),
       ?assertFloat("99 log", 4.59511985014),
       ?assertFloat("99 log10", 1.9956351946),
       ?assertFloat("99 log2", 6.62935662008),
       ?assertRPNError("log", [0]),
       ?assertRPNError("log", [-1]),
       ?assertRPNError("log2", [0]),
  
negative.code: % Rounding
  rounding_methods() ->
      [
       ?assertRPNFloat("3.4 round",  3),
       ?assertRPNFloat("4.5 round",  5),
       ?assertRPNFloat("7.8 round",  8),
       ?assertRPNFloat("-4.2 round", -4),
       ?assertRPNFloat("-4.5 round", -5),
       ?assertRPNFloat("-5.6 round", -6),
       ?assertRPNFloat("3.4 floor",  3),
       ?assertRPNFloat("4.5 floor",  4),
       ?assertRPNFloat("7.8 floor",  7),
       ?assertRPNFloat("-4.2 floor", -5),
       ?assertRPNFloat("-4.5 floor", -5),
       ?assertRPNFloat("-5.6 floor", -6),
       ?assertRPNFloat("3.4 ceil",   4),
       ?assertRPNFloat("4.5 ceil",   5),
       ?assertRPNFloat("7.8 ceil",   8),
       ?assertRPNFloat("-4.2 ceil",  -4),
       ?assertRPNFloat("-4.5 ceil",  -4),
       ?assertRPNFloat("-5.6 ceil",  -5),
       ?assertRPNFloat("3.4 trunc",  3),
       ?assertRPNFloat("4.5 trunc",  4),
       ?assertRPNFloat("7.8 trunc",  7),
       ?assertRPNFloat("-4.2 trunc", -4),
       ?assertRPNFloat("-4.5 trunc", -4),
       ?assertRPNFloat("-5.6 trunc", -5)
      ].
  
  % Bitwise
  bitwise_operations() ->
      [
       ?assertRPNFloat("60 13 &", 12),   % AND
       ?assertRPNFloat("60 13 |", 61),   % OR
       ?assertRPNFloat("60 13 ^", 49),   % XOR
       ?assertRPNFloat("60 ~",    -61),  % NOT
       ?assertRPNFloat("60 2 <<", 240),  % Left Shift
       ?assertRPNFloat("60 2 >>", 15)    % Right Shift
      ].
  
  