newRPL: symbolic numbers

[Gilles]

It seems to me there is a confusion between 'symbolic' and 'exact' here.
Note that the way the 50G works is very different depending of FLAG 03 set or not

Claudio L. Wrote:Following the idea that an approximated number "turns" an exact number into approximated this would be:

'1' '1/2' + --> '3/2'
'1' 0.5 + --> '1.5' (here 1.5 would be an approx. symbolic number)
'3/2*X' 3 * --> '4.5*X' (here 4.5 is approx)
'3/2*X' '3' * --> '9/2*X'

In my opinion, the HP50G 'philosophy' is that there is very few automatic evaluation with symbolic calculation so,i prefer :

Code:


'1' '1/2' + --> '1+1/2' then EVAL (or SIMPLIFY) -> '3/2'  or NUM->  1.5
'1' 0.5 +   --> '1+0.5' then EVAL -> '1.5'  ( approximate 'contagion' but algebraic object)  NUM-> 1.5  (real object)
'3/2*X' 3 * --> '3/2*X*3'  then EVAL '9/2*X' (If X does not exist else  returns  the evaluated expression...)
'1.5' '3.14' + COS --> 'COS(1.5+3.14)'

I like the idea to have a full control of what happens...

Claudio L. Wrote:The other approach would be the opposite: exact numbers turn approximated numbers into exact:
1 '1/2' + --> '3/2'
'1' 0.5 + --> '3/2'
'3/2*X' 3 * --> '9/2*X'
'3*X' 1.5 * --> '9/2*X'

I hate this way

Why don't keep something like the approx ( ~ )and exact ( = ) on the 50G with some improvments ?

in '=' mode ( CAS mode ?) :
- All is symbolic, you have to do ->NUM to get a numeric (no symbolic) result.
- functions returns symbolic results

enter 12 will return '12' (algebraic object)
enter 12. will return '12.' (algebraic)
enter '12.' will return '12.' (algebraic)

ex:

Code:

1 1 2 / +  -> '1+1/2' EVAL -> '3/2'
1.1. 2. / + 'x' * -> '(1.+1./2.)*x'  EVAL (or SIMPLIFY)  -> '1.5*x' (if x undefined)
'1.' '1.' '2.' / + -> '1.+1./2.'  EVAL (or SIMPLIFY)  -> '1.5' 
'SIN(1)' EVAL -> 'SIN(1)'
'SIN(1.) EVAL -> 'SIN(1.)'  
1 '1.5' + -> '1+1.5'   EVAL (or SIMPLIFY)  -> '2.5' 
PI 4  /SIN -> 'SIN(PI/4)'  EVAL -> 'V2/2' (the 50G auto eval in these cases)
`Function` is the same as 'Function'  EVAL  (Auto evaluation of algebraic objects)

in '~' mode (numeric mode):
- All is numeric, you have to quote 'xxx' for algebraic
- functions returns numeric results (and an error if there are undefined values)

enter 12 is the same as 12.
but you can force '12' to get the algebraic object '12' with an integer inside.
or '12.' for an algebraic object '12.' with a real only inside

ex

Code:

12  -> 12.
1 1 2 / + -> 1.5
'1' '1' '2' / +  -> '1+1/2'   EVAL (or SIMPLIFY)  -> '3/2'  ->NUM -> 1.5
'1.' '1' '2' / +  -> '1.+1/2'   EVAL (or SIMPLIFY)  -> '1.5'
1.1. 2. / + -> 1.5
SIN(1)  -> 0.841...
PI 4  /SIN  -> 0.707...
'1' 1.5 + -> 2.5

The difference between = and ~ will be essentialy in the way to input the data in the calc to reduce keystrokes and numeric or algebraic output for functions (that means that there must be a difference between a function (manipulation of algebraic objects) and programs (manipulation of all kinds of objects ...).

= more oriented 'math' (CAS)
~ more oriented 'physics' and numeric calculations

The other major difference will be that with "= mode"
'1' 1. + -> '1+1.'

and in "~ mode"
'1' 1. + -> 2.

In others words

Code:


'blabla'  is an algebraic object (no automatic evaluation)
`blabla` is an algebraic object auto evaluated 
'13.33' is an algebraic object with one real object inside
'1+2' is an algebraic object with an expression)inside '+(1,2)'
13.33 is a real object
13 is an integer object (but I think new RPL dont use integer)
13. is a real object
...

= and ~ just change few (but important) things for more easy use and less keystrokes. You can easily toggle from = to ~ with Shift & ENTER.

~ mode works in the same way of the old 48 serie
== mode is near the 'exact' mode of the 49/50G series but different in some way (and more logical for me but probably i miss some points)
.
Note that in this configuration you _must_ use symbolic to work with 'infinite" integer. (but i've not understand how new RPL will work for this ...).

Just my 2 cents !

I'm quite sure that what I write here is not fully coherent and more 'theoric' thoughts is needed for this.

The keys:
- functions returns 'sym' or 'num' ?
- exact vs approx
- is there an 'infinite integer' type or not ?
- When 'evaluate' ?
- SIMPLIFY vs EVAL