HP-80 Function Question



#2

I recently obtained a HP-80. While experimenting with various functions, I noticed that consecutive presses on (Yellow Shift)+(dot) changes the X value and the stack. Seems like doing some calculation, however couldn't find any information in the manual or elsewhere what type of function it is performing. Any idea? Thanks.


#3

The result is the same as SIGMA+, and there are nothing in the user's manual, if I remember well.

You can make some test to verify the results in the stack:

Reg X SUM of data;

Reg Y Num of data;

Reg Z SUM of X^2;

Reg T the same of Y reg.

HTH

Ignazio

Edited: 10 Feb 2012, 3:02 p.m.


#4

I was suspecting that however, after total clear:
Pressing shift+dot generates:
0
1
2
3
5
11
26
66
227

Pressing sigma+ generates:
0
1
0
-1
-3
-5
-8
-20
-57
-158


#5

That's what shift-dot does on the HP-80, whatever it is, starting from a clear stack:

T: 0 0 0 1 5 14 39 160 836 5192
Z: 0 0 0 1 5 14 39 160 836 5192
Y: 0 1 1 1 2 6 15 40 161 837
X: 0 0 1 2 3 5 11 26 66 227

Here is a BASIC program that produces the contents of stack registers X and Y:

 5 CLS
10 A = 0: B = 0: X = 0: B = 1
20 PRINT X;
25 IF X > 100000 THEN END
30 C = A + B
40 D = B + X * X
50 X = A: A = C
60 Y = B: B = D
70 GOTO 20

0 0 1 2 3 5 11 26 66 227 1064 6257 62979 1251797


#6

An interesting function. I wonder if HP was thinking about another financial or statistical function which later they decided not to include thus never made it to the keyboard. I am still trying to figure out what this calculation could be used for, expecially given the numbers displayed as an integer.


#7

Interestingly most of the first few terms are prime numbers:

1  2  3  5  11  26  66  227  1064  6257  62979  1251797

The next five terms are composites, however:

#include <iostream.h>
int main()
{
unsigned __int64 a = 0, b = 1, c, d, x=0, y=0;
a = 0; b = 1; x = 0; y = 0;
for (char i = 1; i <=19; i++)
{
cout << x <<" ";
c = a + b;
d = b + x*x;
x = a;
a = c;
y = b;
b = d;
}
printf("\n\n");
system("pause");
return 0;
}

0 0 1 2 3 5 11 26 66 227 1064 6257 62979 1251797 41590664 4048283972 1575050706489 1732929385089902 16392067401671570099

RPL in exact mode on the HP 50g will handle those large numbers more easily than C++ though.

-------------

Update:

Yes, better on the HP 50g. No more primes, however. At least up to the 30th term:

\<< 0 1 0 { } 5 ROLL 1 SWAP
START
OVER + 4 ROLLD SQ OVER + UNROT OVER + UNROT 4 ROLL
NEXT
NIP NIP NIP
\>>

{ 0 0 1 2 3 5 11 26 66 227 1064 6257 62979 1251797 41590664 4048283972 1575050706489

1732929385089902 16392067401671570099 2480817510413371984757417

3003049215326694619490920314339 268699879707039689291938317405726741062

6154455520511000772441212952982808207904869679674

9018304589686585177361346575276066985332356116811106581625207

72199625354577617458397144725821313039714237584299630207413759135099490458584

37877322753948333449755694908105760409757253633480079193708681863162233695095397107688419768038237

81329817672362127432945896422480997301874361053470122520313246583652465523649965949269151256069425402568208827505463410739

52127859013413671535047407030236395396849222294009161464949665161373119998521755364631031658322711552753670697410492320867402812466645759
90995845778068297

14346915790067721633176240664001666629165029005346590080187806856469612582037080298125024141950588218469346345125388922632222175608248895
18185403399728040557501172362103337453970311201525586794024

66145392426196670157751694600396451696020482379488309297589369490227493838452111265830722847572958345973667892914792187598144060583637941
60798522338995129532050772296242939524666311575933016041026411697274553914980751285069710677309108416045872 }


Edited: 12 Feb 2012, 4:43 p.m.


#8

Yet another implementation using Python:

def diff(xs):
y = xs.pop(0)
ys = []
for x in xs:
ys.append(x - y)
y = x
return ys

x, y, z, t = 0, 0, 0, 0

xs = []
for i in range(10):
x, y, z, t = x + y, z + 1, t + x**2, t + x**2
xs.append(x)

print xs
dxs = diff(xs)
print dxs
d2xs = diff(dxs)
print d2xs

I calculated the difference between sequent elements:

[0, 1, 2, 3, 5, 11, 26, 66, 227, 1064]
[1, 1, 1, 2, 6, 15, 40, 161, 837]
[0, 0, 1, 4, 9, 25, 121, 676]

This shows that the 2nd difference is the same as the initial sequence squared and shifted.

Or as a recursive formula:
xn+3 = 2 xn+2 - xn+1 + xn2
together with the initial values: x0=0, x1=1, x2=2.

This leads to the simple program:

x = [0, 1, 2]

for n in range(10):
x.append(2*x[n+2] - x[n+1] + x[n]**2)

print x

... which produces the same result:

[0, 1, 2, 3, 5, 11, 26, 66, 227, 1064, 6257, 62979, 1251797]

I've tried in vain to use
WolframAlpha to find a closed form. So I'm afraid there isn't.

Cheers

Thomas

Edited: 13 Feb 2012, 7:06 p.m.


#9

Very nice!

Quote:
I've tried in vain to use
WolframAlpha to find a closed form. So I'm afraid there isn't.

It's not in OEIS either.

Regards,

Gerson.


#10

Quote:
It's not in OEIS either.

You may ask them to add it. I wonder if they'll accept it.

Since after the first step of the recursion t' = z' we can just forget about t:

  1. z' = z + x2
  2. y' = z + 1
  3. x' = x + y

x''' = x'' + y''
y'' = z' + 1 = z + x2 + 1
x'' = x' + y' => x'' - x' = y' = z + 1

x''' = x'' + x'' - x' + x2
= 2 x'' - x' + x2

Just in case somebody might not believe that two sequences are equal when they agree on the first few elements.

Cheers

Thomas

Edited: 14 Feb 2012, 3:13 a.m.

#11

This is my understanding what both operations sigma+ and shift dot do:

T: T + X^2
Z: T + X^2
Y: Z + 1
X: Y + X

However sigma+ seems to change its mind if you don't enter a number and starts to calculate the following instead:

T: T - X^2
Z: T - X^2
Y: Z - 1
X: Y + X

I filled the stack with 1:

sigma+:

T: 1    2   -2  -18  -43
Z: 1 2 -2 -18 -43
Y: 1 2 1 -3 -19
X: 1 2 4 5 2

shift dot:

T: 1    2    6   22   71
Z: 1 2 6 22 71
Y: 1 2 3 7 23
X: 1 2 4 7 14

I can't help but I think you just found a bug. Try the following:

shift CLEAR
7
STO
sigma+
RCL
sigma+
mean

You'll get blinking 9.999999999 99 instead of 7. But you get the correct result when using shift dot instead.

Kind regards

Thomas


#12

Dear Thomas and Gerson,thank you very much for your responses and detailed analysis. I will use your directions and further experiment with this function. I have been away from my HP-80 last couple days. I also noticed that the sequence you enter the numbers (PV first vs n first) for PMT calculation gives different results. This may be due to limited number of registers HP-80 has and trying to utilize the stack as much as possible in order to solve the equation. I have feeling that shift dot is executing some sort of a subroutine which is being used as part of this solver, although it does seems like a bug since under the right conditions works better than the sigma+ function. Your responses have been very helpful, I have much more to think about now. Sincerely.


Possibly Related Threads...
Thread Author Replies Views Last Post
  HP50g: Writing a function that returns a function Chris de Castro 2 306 12-10-2013, 06:49 PM
Last Post: Han
  IFERR function on HP Prime Mic 2 268 12-02-2013, 01:33 AM
Last Post: cyrille de Brébisson
  HP-80 History, Design and Interesting Facts BShoring 1 201 11-30-2013, 08:50 AM
Last Post: Xavier A. (Brazil)
  HP Prime: Dirichlet's eta function recognized but not numerically evaluated Helge Gabert 0 157 11-16-2013, 03:41 PM
Last Post: Helge Gabert
  Possible bug with sqrt function in the HP prime Michael de Estrada 6 360 11-15-2013, 12:49 PM
Last Post: Michael de Estrada
  HP-41 MCODE: The Last Function - at last! Ángel Martin 0 169 11-08-2013, 05:11 AM
Last Post: Ángel Martin
  HP Prime 'where' function bluesun08 11 583 10-29-2013, 06:56 PM
Last Post: Joe Horn
  HP-80 Teardown with pictures Max Stone 10 588 10-24-2013, 09:10 PM
Last Post: Walter B
  HP Prime - Defining a function bluesun08 5 327 10-23-2013, 02:43 PM
Last Post: Han
  HP-80 CHS Exponent Curiosity Max Stone 4 321 10-22-2013, 02:39 PM
Last Post: Max Stone

Forum Jump: