1.4 is a big update and includes a number of RPL backwards compatibility commands in its list of 50+ new commands.

Notably, polar and cylindrical coordinate systems are now supported, similar to the 50g. Set via the

Mode menu, or, classic commands

SPHERE,

RECT,

CYLIN, 2- and 3-component vectors, and complex numbers, are now displayed according to the coordinate system selected. This somewhat obsoletes the (28S-style) P→R and R→P commands, which remain nonetheless. (HP decided to remove them as they introduced the 48; we keep them for backwards compatibility.)

Other 50g commands added:

REPL,

IDIV2.

The classic 50g RPL language (not the command set) is complete, but receives two commands that many thought should have been there all along:

BREAK,

CONTINUE. Along with two commands that merge these commands with IF:

IFTB (if-then-break),

IFTC (if-then-continue). (Naming in the "spirit" of IFTE.)

The big majority of new commands are new ones, though, and, as such, not covered here. (See the 1.4 release notes.) Suffice to say that 20+ new array commands extend by some margin, what you can do with vector/lists/arrays in RPL. Many of the new commands take code fragments (in list, RPL program, or string form) as a parameter, and extend the family of list processing commands (which was already on the 50g level in ND1).

OBJ→ has been extended to custom data types. Those didn't exist on the 50g. This, then, is an example for how a classic command becomes extended beyond its traditional scope.

BigFloat and

ContinuedFraction are data types that have been added, that have no 50g equivalents.

RPL+ is growing up fast. Hash-tables and immediate algebraic expressions have been added. Both are very easy to use.

Combined with the new list processing functions, a coding style is promoted that is shorter and more powerful than classic RPL (trading FOR-loops with array processing functions), but still reads like RPL.

Consider

- Code: Select all
`≪ 40e6 primes DUP`

decr

{ real phi } { real 1 == } doUntil

DROP

{ real 25-2 == } select

total

≫

This (Project Euler problem) computes the sum of the primes below a certain limit, that produce chains of a certain length when applying the Euler totient (phi) function, until a value of 1 is reached.

doUntil applies one code fragment to each component of a list, until another code fragment, a condition, becomes true. As such, one simple keyword replaces a FOR-loop and a DO-UNTIL-loop. It returns two lists, for final iteration value and iteration count.

select picks those elements from one list for which the corresponding element in a second list returns true after applying a condition code fragment. (There's also a simpler array processing command,

filter, that works like this for one list.)

Optional hints (the

real word at the beginning of each code fragment, allow the compiler to optimize run-time performance.

total is modern syntax for

∑LIST.

25-2 is post-fix notation thrown into this (via RPL+'s immediate algebraic expressions, which basically allows you to type

expr when in RPL you had to type

'expr' EVAL), for enhanced readability.

Solving this task in traditional RPL would result in a much longer, harder to read program.

This trend is not going to go away with ND1/MorphEngine. We'll expend more effort to increasing the expressive power of RPL+ than to work on backwards compatibility.

Having said that, work on the CAS is in full swing and it will be fully oriented on the 50g CAS command set. An announcement about the CAS is due soon.