Threaded Mode | Linear Mode

DGM · 04-02-2014, 04:25 PM

How about the ND1 from Naive Designs, a programmable RPL+ calculator that runs on iOS (iPhone, iPod, iPad)? It runs HP48 series-like RPL code with enhancements (right now, about 500 functions), as well as JavaScript.

Note: all programs return this result in the display: 0.693097183059948; when I attempted to

Here is the code for RPL+; it runs in about 3.3 seconds on an iPod 4:

Code:

≪ 1 10000 2 FOR r r @dup IF isEven THEN inv - ELSE inv + END -1 STEP ≫

A much faster version uses a vector and splits it into two parts; it runs in about .1 second on an iPod 4 (written by the creator of ND1:

Code:

≪ 10000..1 inv unzip total swap total swap - neg ≫

And here is one version for J

Code:

function () {

var t = 1;

for (var j = 10000; j >= 2; j--) {

   if (calculator.functions.isEven(j))

      t -= 1/j;

   else {

      t += 1/j;

          }

    }

    return (t);

}

Here is a better version (no testing for even/odd, written by the creator of ND1); this runs in about .07 seconds on an iPhone 5s:

Code:

function() { /*as is*/

    var sum = 0;

    for (var n=9999; n=1; n -= 2)

        sum += 1/n - 1/(n+1);

    return sum;

}

And a third way, by the same person; runs in about ,0006 seconds on an iPhone 5s:

Code:

function() { /*as is*/

    var sum = 0;

    for (var n=9999; n=1; n -= 2)

        sum += 1/(n*(n+1));

    return sum;

}

Check out ND1 on the Apple App Store (or ND0 for a limited trial version); the website is http://www.naivedesign.com/ND1/ND1.html

David Motto

Gerson W. Barbosa · (This post was last modified: 04-02-2014 09:07 PM by Gerson W. Barbosa.)

(04-02-2014 04:25 PM)DGM Wrote: Check out ND1 on the Apple App Store (or ND0 for a limited trial version); the website is http://www.naivedesign.com/ND1/ND1.html

The running times are impressive! I read this too fast and skipped the limited trial version part and ended up getting ND1. I haven't done anything beyond changing the skin to Dark so far. No time to do the quick tour now, but will play with it later.

Gerson.

DGM · 04-03-2014, 03:47 AM

Gerson, I don't think you will regret getting ND1; this is one of the few things I have purchased for my iPod (among the thousands of free apps I have downloaded, some of which I have actually tried). I have written several number theory routines for it, which are available for download to the calculator, and others have written much better things than I have. They are available under the My Data, Shared Folders area of the calculator.

[kby] · 04-04-2014, 02:10 AM

There seems to be dearth of Classics doing the original program…the -55s doing an alternate version. So the -65 does about an hour and 20 min (wasn't watching that closely), using the following fairly brute force code:

LBL
A
EEX
4
STO 8
f
STK (clear stack)
1
gv (Roll-down)
LBL
1
g^ (Roll-up)
CHS
ENT
ENT
gv
gv
RCL 8
./. (div)
+
g
DSZ
GTO
1
RTN

0.693097183

Gerson W. Barbosa · 04-04-2014, 02:19 AM

(04-02-2014 04:25 PM)DGM Wrote: Note: all programs return this result in the display: 0.693097183059948;

Back to an authentic HP device, I get 0.693097183059945297 on the HP-200LX running TurboBCD:

Code:

Program Ex_8_3_b;

var n, s: real;

begin

  s := 0;

  n := 10000;

  repeat

    s := s + 1/(Sqr(n) - n);

    n := n - 2

  until n = 0;

  WriteLn(s:19:18)

end.

It takes 50 seconds, however.

Oh, and close to nothing on my old dv2250br notebook, another authentic HP device Smile

Gerson

Gerson W. Barbosa · 04-04-2014, 02:58 AM

(04-04-2014 02:10 AM)[kby] Wrote: There seems to be dearth of Classics doing the original program…the -55s doing an alternate version.

The only Classics I have are this HP-35 and an HP-45, none of which is programmable. But I could have tried a Spice (the 33C).

This HP-71B version computes two terms per loop while doing the original problem:

1 S=0 @ FOR N=10000 TO 2 STEP -2 @ S=S+1/(N-1)-1/N @ NEXT N @ DISP S

Gerson.

Thomas Klemm · 04-04-2014, 03:26 AM

(04-04-2014 02:10 AM)[kby] Wrote: There seems to be dearth of Classics doing the original program…

Here's a solution for the HP-25 using Werner's idea:

Code:

01 STO 0

02 CLEAR: STK

03 RCL 0

04 1/x

05 x<>y

06 -

07 RCL 0

08 1

09 -

10 STO 0

11 x#0

12 GTO 04

13 Rv

I have no idea how long it will take on real calculator.

Cheers
Thomas

Gerson W. Barbosa · 04-04-2014, 04:10 AM

(04-04-2014 03:26 AM)Thomas Klemm Wrote:
(04-04-2014 02:10 AM)[kby] Wrote: There seems to be dearth of Classics doing the original program…

Here's a solution for the HP-25 using Werner's idea:

Code:

01 STO 0 02 CLEAR: STK 03 RCL 0 04 1/x 05 x<>y 06 - 07 RCL 0 08 1 09 - 10 STO 0 11 x#0 12 GTO 04 13 Rv
I have no idea how long it will take on real calculator.

Cheers
Thomas

1h 12 minutes, extrapolating from the time it takes for 100 on Nonpareil.

Cheers,

Gerson.

Steve Simpkin · 04-04-2014, 04:56 AM

Code:

S0001 LBL S

S0002 0.00002

S0003 +

S0004 STO I

S0005 0

L0001 LBL L

L0002 RCL I

L0003 IP

L0004 ENTER

L0005 x^2

L0006 -

L0007 1/x

L0008 -

L0009 DSE I

L0010 GTO L

L0011 RTN

Using the above code (HP 33s code shown):

My HP 33s arrived at 0.69309718306 in 6:10

My HP 35s arrived at 0.69309718306 in 9:15

DavidM · 04-04-2014, 07:35 AM

How about a new classic? I made an attempt to try the two-term method on the 12C 30th Anniversary Edition:

Code:

01  0

02  STO 0

03  X<>Y

04  ENTER

05  ENTER

06  ENTER

07  1

08  -

09  *

10  1/x

11  ST+ 0

12  Rv

13  2

14  -

15  X=0?

16  GTO 18

17  GTO 04

18  RCL 0

10000 R/S yields 0.693097183
Time: 32 seconds

Not too bad for a super-charged old-timer. If only I could install an ARM chip in my head -- then perhaps it wouldn't be so hard to switch gears and think in terms of RPN coding again. I'm sure I've overlooked optimizations here, but I was just happy to get it pumping out reasonable answers.

Thomas Klemm · 04-04-2014, 07:43 AM

(04-04-2014 04:56 AM)Steve Simpkin Wrote: My HP 35s arrived at 0.69309718306 in 9:15

You can probably make it even slower by using an algebraic expression.

Cheers
Thomas

Marcus von Cube · 04-04-2014, 11:56 AM

(04-04-2014 07:35 AM)DavidM Wrote: How about a new classic?

To get this running on a 15CLe just add labels A, 0 and 1 in the appropriate places. It returns the same answer but takes 40 seconds instead of 32. Still not bad.

Gerson W. Barbosa · (This post was last modified: 04-05-2014 02:43 AM by Gerson W. Barbosa.)

(04-05-2014 01:36 AM)Gerson W. Barbosa Wrote:
(04-04-2014 11:56 AM)Marcus von Cube Wrote: To get this running on a 15CLe just add labels A, 0 and 1 in the appropriate places. It returns the same answer but takes 40 seconds instead of 32. Still not bad.

Halfway closer, 36 seconds:

Code:

01 LBL A 02 STO I 03 0 04 LBL 0 05 RCL I 06 DSE I 07 RCL* I 08 1/x 09 + 10 DSE I 11 GTO 0 12 RTN

Gerson.

P.S.: But that's exactly equivalent to Thomas Kemm's WP 34S version a few pages behind:

Code:

LBL A

0

RCL Y

DEC Z

RCL* Z

1/x

+

DSZ Y

BACK 006

END

Too bad the HP-15C lacks a DEC I instruction. This would've saved a second or two.

This takes 36.6 seconds:

Code:

01 LBL A

02 0

03 X<>Y

04 LBL 0

05 ENTER

06 x^2

07 LST x

08 -

09 1/x

10 R^

11 +

12 x<>y

13 2

14 -

15 TEST 0          ; (x!=0?)

16 GTO 0

17 x<>y

18 RTN

P.P.S: A little bit closer, 35.4 seconds:

Code:

01 LBL A

02 2

03 STO 0

04 CL x

05 X<>Y

06 LBL 0

07 ENTER

08 x^2

09 LST x

10 -

11 1/x

12 R^

13 +

14 x<>y

15 RCL- 0

16 TEST 0          ; (x!=0?)

17 GTO 0

18 x<>y

19 RTN

Steve Simpkin · (This post was last modified: 04-05-2014 10:14 AM by Steve Simpkin.)

(04-04-2014 07:43 AM)Thomas Klemm Wrote:
(04-04-2014 04:56 AM)Steve Simpkin Wrote: My HP 35s arrived at 0.69309718306 in 9:15
You can probably make it even slower by using an algebraic expression.

Cheers
Thomas

You got that right. Based on 1000 cycles I estimate it would take 27:30 to arrive at the answer using an algebraic equation. A single term version would be even slower.
It's funny that my first computer (an Ohio Scientific C1P) and my latest HP calculator (a HP 35s) were purchased 35 years apart but are both powered by a 6502 microprocessor.

Thomas Klemm · (This post was last modified: 04-05-2014 05:08 PM by Thomas Klemm.)

Quote:I took your HP-11C program that sums an alternating series ...

Let's go back to Valentin's program. It uses Euler's transform to improve convergence. While Valentin's program handles the general case we can do the same for that specific series.

This leads to the following program for the HP-11C which is shorter, faster and more accurate:

Code:

001 - 42,21,11  LBL A      

002 -    44  1  STO 1      

003 -       34  x<>y       

004 -    44  0  STO 0      

005 -    44 25  STO I      

006 -    43 35  CLx        

007 - 42,21, 0  LBL 0      

008 -    45 25  RCL I      

009 -    42  5  DSE        

010 -    45 25  RCL I      

011 -       20  x          

012 -       15  1/x        

013 -       40  +          

014 -    42  5  DSE        

015 -    22  0  GTO 0      

016 -    44  2  STO 2      

017 -    45  1  RCL 1      

018 -       26  EEX        

019 -       40  +          

020 -    44 25  STO I      

021 -    43 35  CLx        

022 -    22  2  GTO 2      

023 - 42,21, 1  LBL 1      

024 -    45 25  RCL I      

025 -       20  x          

026 - 42,21, 2  LBL 2      

027 -       26  EEX        

028 -       40  +          

029 -    45 25  RCL I      

030 -    45  0  RCL 0      

031 -       40  +          

032 -       10  /          

033 -        2  2          

034 -       10  /          

035 -    42  5  DSE        

036 -    22  1  GTO 1      

037 -    45  2  RCL 2      

038 -       40  +          

039 -    43 32  RTN

As with Valentin's original program you can specify the number of terms to sum initially (M) and the number of differences to compute (N). However make sure M is even.

Example:
12 ENTER
10 GSB A

The result 0.6931471806 is exact to all 10 places and is equal to $log(2)$ as it should be. It takes about 17 seconds using Nonpareil which will be about the same as with the real calculator.

Now beat that with brute force.

Cheers
Thomas

For those interested here's a Python program:

Code:

M = 12

N = 10

r, n = 0, M

while n > 0:

    r += 1./n/(n - 1)

    n -= 2

s, n = 0, N + 1

while True:

    s = (1. + s)/(M + n)/2

    n -= 1

    if n == 0:

        break

    s *= n

print r + s

Steve Simpkin · 04-05-2014, 05:09 PM

(03-29-2014 05:41 PM)Steve Simpkin Wrote:
(03-29-2014 12:36 AM)Tugdual Wrote: Nobody mentioned that entering $$\sum _{ K=1 }^{ 10000 }{ \frac { { (-1 })^{ K+1 } }{ K } }$$ on the Prime with no need for any sort of coding would instantly return 0.693097183025
Is that off scope consideration for this thread?
I know that the prime is blazing fast but the speed is so impressive that I wonder if the calculator is actually performing a loop?

For reference:
The TI-36X Pro arrived at the answer of 0.693097183 in 5:45 minutes.
The Casio fx-115ES Plus took just over 11 minutes to arrived at the answer of 0.6930971831.
It's a good thing these models are solar powered
Not bad for $20 machines.

The Casio ClassPad 330 takes 57.5 seconds to reach 0.6930971831

Gerson W. Barbosa · (This post was last modified: 04-06-2014 03:59 AM by Gerson W. Barbosa.)

(04-05-2014 05:02 PM)Thomas Klemm Wrote:
Quote:I took your HP-11C program that sums an alternating series ...

Let's go back to Valentin's program. It uses Euler's transform to improve convergence. While Valentin's program handles the general case we can do the same for that specific series.

This leads to the following program for the HP-11C which is shorter, faster and more accurate:

Code:

001 - 42,21,11 LBL A 002 - 44 1 STO 1 003 - 34 x<>y 004 - 44 0 STO 0 005 - 44 25 STO I 006 - 43 35 CLx 007 - 42,21, 0 LBL 0 008 - 45 25 RCL I 009 - 42 5 DSE 010 - 45 25 RCL I 011 - 20 x 012 - 15 1/x 013 - 40 + 014 - 42 5 DSE 015 - 22 0 GTO 0 016 - 44 2 STO 2 017 - 45 1 RCL 1 018 - 26 EEX 019 - 40 + 020 - 44 25 STO I 021 - 43 35 CLx 022 - 22 2 GTO 2 023 - 42,21, 1 LBL 1 024 - 45 25 RCL I 025 - 20 x 026 - 42,21, 2 LBL 2 027 - 26 EEX 028 - 40 + 029 - 45 25 RCL I 030 - 45 0 RCL 0 031 - 40 + 032 - 10 / 033 - 2 2 034 - 10 / 035 - 42 5 DSE 036 - 22 1 GTO 1 037 - 45 2 RCL 2 038 - 40 + 039 - 43 32 RTN
As with Valentin's original program you can specify the number of terms to sum initially (M) and the number of differences to compute (N). However make sure M is even.

Example:
12 ENTER
10 GSB A

The result 0.6931471806 is exact to all 10 places and is equal to $log(2)$ as it should be. It takes about 17 seconds using Nonpareil which will be about the same as with the real calculator.

Looks like my HP-11C is a bit slower: 18.7 seconds.

(04-05-2014 05:02 PM)Thomas Klemm Wrote: Now beat that with brute force.

What about another non brute force program?

Code:

01 LBL A

02 STO I

03 STO 0

04 CLx

05 LBL 0

06 RCL I

07 DSE I

08 RCL I

09 *

10 1/x

11 +

12 DSE I

13 GTO 0

14 RCL 0   

15 STO I  

16 2

17 *

18 1

19 +

20 STO 0

21 CLx

22 LBL 1

23 RCL 0

24 +

25 RCL I

26 x^2

27 x<>y

28 /

29 DSE

30 GTO 1

31 RCL 0

32 +

33 1/x

34 +

35 RTN

4 10 GSB A --> 0.6931471805 ( 13.4 s )

5 8 GSB A --> 0.6931471806 ( 11 s )

7 6 GSB A --> 0.6931471807 ( 8.5 s )

The first parameter is the number of terms in the continued fraction, minus one. The second parameter, always even, is the number of computed terms in the series. I have assumed the continued fraction terms follow a pattern, but this has yet to be checked.

Cheers,

Gerson.

Edited to correct line 21 (CLx, not 0).

Thomas Klemm · 04-06-2014, 06:24 AM

Now we have 3 different ways to calculate the same thing:

Borwein's formula using tangent numbers
Convergence acceleration using Euler's transformation
Gerson's method using continued fractions

Do you have a proof of your formula or is it still a conjecture? Congratulations to your discovery! Your method appears to be more efficient than the other two.

Kind regards
Thomas

Quote:The first parameter is the number of terms in the continued fraction, minus one.

This parameter is ignored. Instead the 2nd parameter is used twice (cf. lines 14-15).

Gerson W. Barbosa · (This post was last modified: 04-06-2014 12:17 PM by Gerson W. Barbosa.)

(04-06-2014 06:24 AM)Thomas Klemm Wrote: Now we have 3 different ways to calculate the same thing:

Borwein's formula using tangent numbers

Convergence acceleration using Euler's transformation

Gerson's method using continued fractions

Do you have a proof of your formula or is it still a conjecture? Congratulations to your discovery! Your method appears to be more efficient than the other two.

No, the proof has yet to be found (in case there isn't one already), by someone more capable than I. I only found this empirically, using the WP 34S in double precision and the sum of the first 10000 terms of the series, the difference to ln(2) being found to be 1/20001 + (1/20001 + 4/(20001 + 9/(20001 + 16/(20001 + ... Then I assumed the next numerators to be 25, 36, 49...

(04-06-2014 06:24 AM)Thomas Klemm Wrote:
Quote:The first parameter is the number of terms in the continued fraction, minus one.
This parameter is ignored. Instead the 2nd parameter is used twice (cf. lines 14-15).

Thank you very much! The timings and results were indeed strange. I ought to have checked them more carefully. I think I got it right this time. Faster, and only one step longer:

Code:

01 LBL A

02 STO I

03 STO 0

04 CLx

05 LBL 0

06 RCL I

07 DSE 

08 RCL I

09 *

10 1/x

11 +

12 DSE  

13 GTO 0

14 RCL 0   

15 2

16 *

17 1

18 +

19 STO 0

20 Rv

21 x<>y

22 x<>I

23 LBL 1

24 RCL 0

25 +

26 RCL I

27 x^2

28 x<>y

29 /

30 DSE

31 GTO 1

32 RCL 0

33 +

34 1/x

35 +

36 RTN

4 10 GSB A --> 0.6931471806 ( 9 s )

5 8 GSB A --> 0.6931471805 ( 8.9 s )

6 8 GSB A --> 0.6931471806 ( 9.6 s )

10 4 GSB A --> 0.6931471808 ( 11 s )

7 6 GSB A --> 0.6931471805 ( 8.6 s )

6 6 GSB A --> 0.6931471807 ( 8.4 s )

Cheers,

Gerson.

P.S.: My HP-15C (2905B29505) is somewhat slower:

4 10 GSB A --> 0.6931471806 ( 10.2 s )

Code:

01 LBL A

02 STO I

03 STO 0

04 CLx

05 LBL 0

06 RCL I

07 DSE I

08 RCL* I

09 1/x

10 +

11 DSE I

12 GTO 0

13 2   

14 RCL* 0

15 1

16 +

17 STO 0

18 Rv

19 x<>y

20 x<> I

21 LBL 1

22 RCL+ 0

23 RCL I

24 x^2

25 x<>y

26 /

27 DSE I

28 GTO 1

29 RCL+ 0

30 1/x

31 +

32 RTN

On the other hand the HP-15C LE might do it in about 70 ms :-)

Gerson W. Barbosa · 04-06-2014, 07:14 PM

(04-06-2014 11:24 AM)Gerson W. Barbosa Wrote: ...

Here is the WP 34S version I used in the tests below:

Code:

001 LBL A

002 STO 00

003 #000

004 RCL Y

005 DEC Z

006 RCL* Z

007 1/x

008 +

009 DSE Y

010 BACK 006

011 x<> Y

012 RCL 00

013 RCL+ 00

014 INC X

015 STO 00

016 Rv

017 RCL+ 00

018 RCL Z

019 x^2

020 x<> Y

021 /

022 DSE Z

023 BACK 006

024 RCL+ 00

025 1/x

026 +

027 END

A few tests:

ln(2) = 0.693 147 180 559 945 309 417 232 121 458 176 6
0000 10 0.693 253 968 253 968 253 968 253 968 253 968 2
0001 10 0.693 146 232 852 115 205 056 381 526 969 762 2
0002 10 0.693 147 199 088 903 124 777 564 239 447 647 5
0003 10 0.693 147 179 934 047 533 616 963 111 042 766 6
0004 10 0.693 147 180 591 838 917 151 717 921 689 047 7
0005 10 0.693 147 180 557 698 640 308 793 387 120 326 6
0006 10 0.693 147 180 560 151 141 269 127 925 193 192 9
0007 10 0.693 147 180 559 921 861 907 989 655 280 666 1
0008 10 0.693 147 180 559 948 518 422 585 061 218 105 6
0009 10 0.693 147 180 559 944 795 810 073 447 374 954 4
0010 10 0.693 147 180 559 945 403 501 429 756 457 393 5
0011 10 0.693 147 180 559 945 290 034 306 855 638 774 6
0012 10 0.693 147 180 559 945 313 843 885 909 537 467 7
0013 10 0.693 147 180 559 945 308 309 916 220 520 106 8
0014 10 0.693 147 180 559 945 309 717 580 283 035 902 1
0015 10 0.693 147 180 559 945 309 329 648 921 158 750 2

ln(2) = 0.693 147 180 559 945 309 417 232 121 458 176 6
000 100 0.693 147 303 688 304 655 980 964 290 653 683 0
001 100 0.693 147 180 547 757 700 150 739 640 428 249 6
002 100 0.693 147 180 559 948 023 068 705 311 333 583 0
003 100 0.693 147 180 559 945 308 343 448 458 203 194 3
004 100 0.693 147 180 559 945 309 417 895 721 522 250 6
005 100 0.693 147 180 559 945 309 417 231 531 226 281 8
006 100 0.693 147 180 559 945 309 417 232 122 172 268 2
007 100 0.693 147 180 559 945 309 417 232 121 457 048 9
008 100 0.693 147 180 559 945 309 417 232 121 458 178 8
009 100 0.693 147 180 559 945 309 417 232 121 458 176 5

ln(2) = 0.693 147 180 559 945 309 417 232 121 458 176 6
000 754 0.693 147 180 850 970 999 061 854 488 660 451 3
001 754 0.693 147 180 559 944 798 193 588 178 902 729 7
002 754 0.693 147 180 559 945 309 419 252 678 647 244 8
003 754 0.693 147 180 559 945 309 417 232 107 260 863 2
004 754 0.693 147 180 559 945 309 417 232 121 458 332 4
005 754 0.693 147 180 559 945 309 417 232 121 458 176 5

ln(2) = 0.693 147 180 559 945 309 417 232 121 458 176 6
0 10000 0.693 147 180 560 070 290 667 544 855 833 947 1
1 10000 0.693 147 180 559 945 309 415 982 433 958 165 6
2 10000 0.693 147 180 559 945 309 417 232 121 486 291 7
3 10000 0.693 147 180 559 945 309 417 232 121 458 176 5

Well, we got the idea.