Algoritmusok

[Sanyi]

Még a TI-Nspire topikban ( http://groups.google.hu/group/szamologep/browse_thread/thread/da15ef1096d2eadd
) merült fel a "tömbös", vagy "listás" módszer a nagyon nagy egész
számok vagy végtelenbe nyúló tizedestörtek (pl. pi) minél pontosabb
meghatározására.
A módszer szerintem régi, még tán egy informatika-tanárom vezetett rá,
és magam is többször "felfedeztem már" újra.
A lényeg: a számjegyeket tömbben tárolva az alapértelmezettnél jóval
pontosabban meghatározhatunk számokat.
Pl. egy egyszerű esetben (kissé pocsékolva) a tömb (lista) egy-egy
elemében egy-egy számjegyet (tizedesjegyet) tárolhatunk. Így akár,
megfelelő algoritmussal, ha a számológép mondjuk megengedi pl. 1000
elemszámú tömbök létrehozását, akár 1000 jeggyel (tizedesjeggyel) is
számolhatunk. No persze az algoritmus létrehozása ennél az egyszerű
elméletnél jóval bonyolultabb lehet ;)

Egy egyszerű példa: kettő hatványainak meghatározása olyan szintig,
amire a számológép már nem lenne képes a beépített számábrázolásával:
Vegyünk egy tömböt. Az utolsó (mondjuk 1000.) elemébe írjunk be 2-t.
Szorozzuk be kettővel, s így tovább. Ha pár lépés után túlcsurdul (8
után 16-ra pl.), akkor az eggyel előtte lévő cellába, elembe írjuk be
az 1-et, az 1000.-ben pedig marad a 6.
Végigszorozzuk megint az elemeket (gyorsabb az algoritmus ugye, ha nem
mind az 1000-et szorozzuk, hanem figyelünk, hogy visszafelé hol
tartunk, tehát csak az utolsó 2-t, stb. szorozzuk), figyelve a
túlcsordulásokra.
Ez így ebben az egyszerű formában persze elég "helypocsékló" megoldás,
mivel 1-1 lista (tömb) cellában csak egy egész értéket, azaz egy
"számjegyet" tárolunk, cserébe viszont viszonylag gyors. Stb.

Hasonló elvet esetleg a pi közelítésére is használhatunk, valamilyen
közelítő módszert kellően átalakítva.

[tolosa]

Akkor inkább itt válaszolok Pipásnak is a felvetett problémára.

A lényeg: szerintem -és az eredményed szerint- csak az emulátor
viselkedik így. Elvégeztem én is a hatványozást a HP-n és bizony a 21-
es flag beállítása esetén bármilyen olyan számításnál, amikor az
eredmény nagyobb lenne 9.999.....9E499-nél, a gép "Overflow"
hibajelzést ad.
Ennek megfelelően például a 100^249 és akár a 100.5^249 is
értelmezhető eredményt ad, de a 100^250 művelet már túlcsordulást
eredményez.
Szóval valószínűleg az emulátor inkább a PC számábrázolási képességeit
tükrözi - ebben az esetben.

[Pipás]

Kösz a választ Tolosa, kétszeresen is leszisszentem.:-)
1. Mikor rájöttem hogy a HP csak egész számokkal képes ekkora
hatványozásra.
2. Meg most mikor kiderült hogy a HP nem képes rá, csak az emulátor.:-
(
(Pedig már hergeltem magam hogy: Há, na ugye! Ilyesmire kell használni
egy ARM processzor teljesítményét!)
Azért még nem tettem le teljesen a csempészkörút gondolatáról.:-)

[Pipás]

Neked is kösz Sanyi, átrágtam magam az infókon. Akkor itt a
'túlcsordulás' azt jelenti hogy az eredmény több mint 10, vagyis ugrik
egy helyértéket. Egy példán bemutatva:
2^8= 256 -ot kiszámolva és egy 4 elemű listát véve az elemeket
egyenként a végétől visszafelé haladva kettővel beszorozva:
1. {0, 0, 0, 2} *2
2. {0, 0, 0, 4} *2
3. {0, 0, 0, 8} *2 < Itt több mint 10, az előző elemhez adok 1-et
4. {0, 0, 1, 6} *2
5. {0, 0, 3, 2} *2
6. {0, 0, 6, 4} *2 < Itt több mint 10, az előző elemhez adok 1-et
7. {0, 1, 2, 8} *2 < Itt több mint 10, az előző elemhez adok 1-et
8. {0, 2, 5, 6}

Határozottan ügyes. ;-)

On márc. 13, 21:53, Sanyi <cs...@freemail.hu> wrote:
> Még a TI-Nspire topikban (http://groups.google.hu/group/szamologep/browse_thread/thread/da15ef1...

[Pipás]

A Pi nap örömére itt egy algoritmus Delphiben Pi értékének
Leibnitz-féle sorral való kiszámítására.
Pi = 4 * (1 - 1/3 + 1/5 - 1/7 + ...)
http://falu.me/2009/01/13/a-pi-ertekenek-szamitasa-iteracios-modszerrel
Ugyanez TI-Basic nyelven:

Ahol
-> = STO
=< = Rombusz + 0
Használata: leibpi(ciklusszám)

leibpi(iter)
Prgm
Local n_it,nev
1->n_it:3->nev
1->res

While n_it=<iter
If n_it/2=iPart(n_it/2) Then
res+1/nev->res
Else
res-1/nev->res
Endif
n_it+1->n_it
nev+2->nev
EndWhile

Disp approx(res*4)
EndPrgm

Az egyszer már futtatott (előfordított) program futásideje
leibpi(1000) értékre 1 perc 18 másodperc a Plusszon. (Ja, Basic-ben
van.) Ekkor az eredmény:
3. 14259165434, két tizedes pontosságú.
Ha a " Disp approx(res*4)" sort behelyezzük a ciklusba az "EndWhile"
elé akkor a futás nyilván lelassul, de érdekes látni hogy közelít az
algoritmus 2 oldalról a Pi felé. A max. pontosság a TI számábrázolása
miatt 11 tizedesjegy Isten tudja mennyi idő alatt. :-)

Boldog Pi napot!

[tolosa]

Ha igaz, ennek a formulának van egy közvetlenebbül alkalmazható
változat is /zsebszámolón program nélkül alkalmazható/:

∞ (-1) ˆ k+1
π/4=∑-----------------
k=1 2*k-1

Na most lehet, hogy összekuszálódik ez a képlet...

On márc. 14, 17:29, Pipás <litauszky_gyo...@t-online.hu> wrote:
> A Pi nap örömére itt egy algoritmus Delphiben Pi értékének
> Leibnitz-féle sorral való kiszámítására.

> Pi = 4 * (1 - 1/3 + 1/5 - 1/7 + ...)http://falu.me/2009/01/13/a-pi-ertekenek-szamitasa-iteracios-modszerrel

[tolosa]

A HP-n 1000-es felső korláttal számolva kb. 12 mp-ig tart a futás és
az eredmény /a 4-el való szorzás után/ 3.14059265379

[tolosa]

10000-es felső korláttal számolva már jelentősen megnő a számolási idő
-úgy 2 percre saccoltam- és a végeredmény:3.14149265367.

[tolosa]

A számlálóban a "k+1" kitevő után látható függőleges vonalnak nincs
matematikai jelentése, csak valamiért odakerült.

On márc. 14, 20:01, tolosa <tol...@freemail.hu> wrote:

[Pipás]

Köszi kipróbálom, de találtam egy érdekes linket szerintem azon a
honlapon, ahonnan Te a Pi hegyláncait ajánlottad.
http://t-t.freeweb.hu/minden/tudom/pii04.htm
Itt a Leibniz-sorozatról van szó. A cikk végén azt írja: Ami nekem 1.3
percig tartott (1000) lépés, az Pascalban Pentiummal 0.05 másodperc.
De ami a legfontosabb: minden újabb tizedesjegy kiszámítása
megtízszerezi a számítási időt. Azért ez elég durva, nem?

[Sanyi]

Jó hogy találtad ezt az oldalt Pipás, mert épp ezzel a Leibniz-
sorozattal terveztem közelíteni a pi-t... de akkor most már tudom,
hogy ezzel (főleg a Casio sebességével...) évek alatt sem számítanám
ki a pi-t 200-250 tizedesjegyig.... :)

[Pipás]

Szuper a képlet, a futásidő 1000-ig nálam 35 másodperc, az eredmény
3.14059265384, nálad ..379.
Hogy tetted fel ilyen alakban a fórumra?

On márc. 14, 20:01, tolosa <tol...@freemail.hu> wrote:

[Pipás]

Én is pont azon gondolkozom hogy ez a feladat nem a mi gépeinknek
való. Körömollóval nem érdemes nekiállni lenyírni a füvet egy
parkban.:-) De kisebb értékekig próba vagy szemléltetésképpen érdemes
kipróbálni. (Már írtam egyet délután Delphiben is csak még alakítgatni
kell. Gyorsabb lett mint a TI, de egy két plusz nulla után az is
belassul.)

[tolosa]

"Hogy tetted fel ilyen alakban a fórumra? "

Nehezen.:-)

Az XP karaktertábla segítségével.

[tolosa]

"Én is pont azon gondolkozom hogy ez a feladat nem a mi gépeinknek
való."

Viszont nagyon jól el lehet szórakozni ezekkel a dolgokkal, nem?:-)

[Pipás]

Ja és akkor összeraktad. Jól sikerült. Egyébként tényleg jó ez a
formula, Tolosa! Megmértem 10000-re is az időt, nálam 2 perc 20
másodperc. Ez 140/35= pont négyszeres futásidő, és nem tízszeres mint
az fenti linkben írták a Leibniz sorozatról. Mégis adott egy plusz
tizedesjegyet: 3.14149265359.

[Pipás]

Hát az nem kifejezés.:-)

On márc. 14, 21:37, tolosa <tol...@freemail.hu> wrote:
> "Én is pont azon gondolkozom hogy ez a feladat nem a mi gépeinknek
> való."
>

[Pipás]

Ez a formula 1000-re lassabb, 10000-re egy kicsit gyorsabb az
előzőnél.

∞ 1
1/6*π^2=∑ ---------
k=1 k^2

[tolosa]

Lehet, hogy már a könyökötökön jön ki, de talátam egy újabb formulát,
ami tényleg nagyon gyors.

π ∞ (2n)ˆ2
- = ∏ ------------------
2 n=1 (2n-1)*(2n+1)

[tolosa]

Wallis-formula a neve.

[Pipás]

Kipróbáltam, tényleg gyorsabb.
10000 lépésre 3.5 perc a 2' 20'' helyett, de 3 helyett 4 tizedes
pontosság.
5000 lépésre 3 tizedes pontosság 1 ' 55'' , 25 másodperccel hamarabb,
és fele annyi lépéssel mint az előző formuláddal.

[Pipás]

Csuda pofás képleteket tudsz már írni a Windows karakterkészlettel,
Tolosa! :-)

[tolosa]

Na ne! Te is ugyanúgy megírtad azt a képletet,nem?:)

[tolosa]

Az a baj, hogy az eredeti problémát nem tudom megoldani, akárhány
közelítő formulát találok, vagyis a tizedesjegyek számát nem tudom
növelni azon a bizonyos határon túl. Tehát max. annyi jegy lesz,
ahányat a zsebszámoló egyszerűen a PI lehívásával is adna.

[tolosa]

Most, hogy az utolsó formulával próbálkoztam, viszont arra jöttem rá,
hogy a HP-n nincs ∏ /szorzatösszeg/ funkció - vagy csak én nem
találom.
Ha esetleg valamelyikőtök felfedezné az emulátoron, ossza meg velem a
titkot.:-)

[Pipás]

Hát nekem könnyű volt, mert csak átmásoltam a karaktereket a
tiedből. ;-)
Láttad már a Wikipedia Pi formuláit?
http://en.wikipedia.org/wiki/Numerical_approximations_of_%CF%80
A modern algoritmusoknál rögtön az elsőnél azt írja hogy 100 tizedesig
számol 3 lépésben, és trillió tizedes felett van 20 lépésben. :-o

[tolosa]

No, itt már olyan bonyolult formulák is vannak, hogy nem a
megértésükre, de még a számológépbe való hibátlan beírásukra sem
vállalkoznék.:-)

On márc. 15, 18:51, Pipás <litauszky_gyo...@t-online.hu> wrote:
> Hát nekem könnyű volt, mert csak átmásoltam a karaktereket a
> tiedből. ;-)

> Láttad már a Wikipedia Pi formuláit?http://en.wikipedia.org/wiki/Numerical_approximations_of_%CF%80

[Pipás]

Azért vannak benne érdekes dolgok a pl."Miscellaneous
approximations" (Vegyes megközelítések) részben. Például a

(2143/22)^(1/4)

képlet egy gombnyomásra kiadja a Pi-t nálam 8 tizedesre. Nyilván ez
nem ugyanaz a módszer, de azért érdekes.Van ilyen képlet 52
tizedesjegyre is.

[Litauszky György]

 

Még egy kis π:

Kíváncsi voltam hogy közelíti  π-t a Tolosa által beírt két képlet ezért ábrázoltam őket grafikusan a Plusszon.
Érdekes látni hogy amíg a Leibniz formula oszcillálva, addig a Wallis alulról közelít. Valószínűleg ennek köszönhetően  nagyobb a sebessége.

 

Leibniz formula:
       ∞  (-1) ˆ k+1
π/4=∑------------
      k=1      2*k-1

 

A hozzá tartozó függvény:

 

leibniz(in)
Func
 Local out
   ∑((-1)^(k+1)/(2*k-1),k,1,in)->out
 out*4->out
EndFunc

 

Wallis formula:

π    ∞        (2n)ˆ2
- = ∏    ------------------
2   n=1  (2n-1)*(2n+1)

 

A hozzá tartozó függvény:

 

wallis(in)
Func
 Local out
  ∏((2*n)^2/((2*n-1)*(2*n+1)),n,1,in)->out
 out*2->out
EndFunc

 

Függvénygörbék: 1. kép
Y szerkesztő:          2. kép
Ablakbeállítás:       3. kép

[Pipás]

Nálam a Google képletöltésnél szerverhibát jelez.
Mindenesetre leírom ide is az ablakbeállításokat:
xmin=-1, xmax=19, xscl=1, ymin=2.64, ymax=4.01, yscl=.1, xres=6.

[Sanyi]

Nagyon jó ez a pi közelítő kép Pipás.

Hétvégén én is fogalkoztam a témával, újra lefuttattam a nem túl
hatékony "direkt pi" véletlenszámos pi közelítő algoritmust:
http://szamologep.blogspot.com/2009/04/pi-kozelito-program-casio-grafikus.html
A korábbi kísérletnél 5316-ig futott a ciklus, és 4151 "véletlen-pont"
jutott a körbe, így pi értékére 3,1234... jött ki.
Most 17054-ig futtattam, 13388 volt a körben, így 3,14014... jött ki
pi-re.
(A Casio elég lassú, így ez kb. 4 órás futási időt jelentett:)

[tolosa]

Sanyi, Pipás!

Találtam egy csoda kis programot, ami semmi perc alatt kiszámolja a PI
akárhány tizedesjegyét és a forrásfájl is hozzáférhető.
Mivel Ti vágjátok a programozást, én meg ahhoz kutyaütő vagyok, nincs
kedvetek kalkulátorra átdolgozni a programot?

http://www.pisymbol.com/apps/picalc/

Egy eredmény: /PC-n nem mérhetően rövid idő alatt kiszámolva/

3.
14159 26535 89793 23846 26433 83279 50288 41971 69399 37510
58209 74944 59230 78164 06286 20899 86280 34825 34211 70679
82148 08651 32823 06647 09384 46095 50582 23172 53594 08128
48111 74502 84102 70193 85211 05559 64462 29489 54930 38196
44288 10975 66593 34461 28475 64823 37867 83165 27120 19091
45648 56692 34603 48610 45432 66482 13393 60726 02491 41273
72458 70066 06315 58817 48815 20920 96282 92540 91715 36436
78925 90360 01133 05305 48820 46652 13841 46951 94151 16094
33057 27036 57595 91953 09218 61173 81932 61179 31051 18548
07446 23799 62749 56735 18857 52724 89122 79381 83011 94912
98336 73362 44065 66430 86021 39494 63952 24737 19070 21798
60943 70277 05392 17176 29317 67523 84674 81846 76694 05132
00056 81271 45263 56082 77857 71342 75778 96091 73637 17872
14684 40901 22495 34301 46549 58537 10507 92279 68925 89235
42019 95611 21290 21960 86403 44181 59813 62977 47713 09960
51870 72113 49999 99837 29780 49951 05973 17328 16096 31859
50244 59455 34690 83026 42522 30825 33446 85035 26193 11881
71010 00313 78387 52886 58753 32083 81420 61717 76691 47303
59825 34904 28755 46873 11595 62863 88235 37875 93751 95778
18577 80532 17122 68066 13001 92787 66111 95909 21642 01989

On márc. 17, 07:23, Sanyi <cs...@freemail.hu> wrote:
> Nagyon jó ez a pi közelítő kép Pipás.
>
> Hétvégén én is fogalkoztam a témával, újra lefuttattam a nem túl

> hatékony "direkt pi" véletlenszámos pi közelítő algoritmust:http://szamologep.blogspot.com/2009/04/pi-kozelito-program-casio-graf...

[tolosa]

Az első 100000 jegyet az én gépemen /PC-n/ 1 perc 25 mp alatt
számította ki.

[Sanyi]

Hát, kihívásnak szép, de úgy látom, ez már kifog az én programozói
tudásomon...
Már régen foglalkoztam C-vel és C++-szal, s eléggé át kell magát
rágnia egy ilyen kódon az embernek, hogy megértse...
A kalkulátor nyelvére való átalakításról nem is beszélve...
Szóval ennek én nem merek nekiugrani, lelkesedés ide vagy oda :)
De jó kis program, az tény, köszi Tolosa!
(Ugyanakkor nagyon kíváncsi vagyok egy olyan programra - ha létezik
ilyen -, ami grafikus kalkulátoron számolgat pi jegyeket, akár csak
pár tíz vagy pár száz jegyig... :))

[tolosa]

Csak kíváncsiságból -egy másik hasonló progival- kiszámoltam az első
32 000 000 /32 millió/ számjegyét /ha valakinek kell, elküldöm egy 36
megás ".txt" -fájlban:-)/ és mindez 23 perc 8 mp-ig tartott.

[tolosa]

Hát igen, nekem is egy ilyenre fáj a fogam!
Aztán lehet, hogy már többször is ott volt az orrom előtt, csak-
megfelelő nyelvtudás nélkül- nem ismertem fel.

[tolosa]

Viszont az, hogy most már könnyedén hozzájuthatok egy ilyen hatalmas
méretű adathalmazhoz a PI-számjegyeiből, lehet, hogy kedvet ad nekem
régi hobbim újraélesztéséhez és elvégzek rajta néhány statisztikai
elemzést.:-)
Hátha éppen én fedezem fel benne azt a régóta kutatott
törvényszerűséget!:-)
Persze ez csak vicc a javából.:-)

[Sanyi]

Találtam egy programot, ami TI-89-en pi-t számolgat akár 4676 jegyig:
http://www.ticalc.org/archives/files/fileinfo/397/39731.html
A dolog szépséghibája, hogy C-ben íródott, nem a gép "saját nyelvén".

[tolosa]

Sajnos ez nem az igazi.

[Sanyi]

Hát igen, ezt én is így érzem ;)
Viszont rájöttem, hogy a Leibniz-sorozatra ( pi = 4 - 4/3 + 4/5 - 4/7
+ 4/9.....) pofonegyszerű programot írni számológépen.
Először elbonyolítottam, mert mindenképp a "tömbös módszerrel" akartam
dolgozni, viszont ugye ez a módszer nagyon lassan adja ki a
tizedesjegyeket (lásd a linket valahol a topik elején), így felesleges
a tömbös módszer, bőven elég sima változókkal dolgozni. Így egy nagyon
szimpla ciklus az egész.

De ez inkább csak "érdekesség", mert ezzel még a gép beépített pi-jét
sem lehet nagyon elérni, már pár tizedesjegynyi pontosság elérése is
órákba telhet egy kalkulátoron.

[Pipás]

"Találtam egy csoda kis programot"
Kösz a linket Tolosa, de a C nekem sem megy.
Találtam viszont egy programot TI Basic-ben 92 Plusz, Voyage-200 és
TI-89 változatban:
http://www.ticalc.org/archives/files/fileinfo/388/38855.html
A program szintén számjegyenként tárolja az eredményt egy listában,
hasonlóan Sanyi algoritmusához. Azt írja a szerzoje hogy eredetileg
FoxPro-ban és Basic-ben írta Pc-re. 100 tizedesig a Pc 1 másodpercet,
a Plusz közel fél órát számol . (Majd átnézem.)

[tolosa]

Van itt egy link, ahol a PI számjegyeiben kereshettek tetszőleges
számsorozatot.
Érdekes.:-)

http://www.angio.net/pi/bigpi.cgi

[Pipás]

"Viszont rájöttem, hogy a Leibniz-sorozatra ( pi = 4 - 4/3 + 4/5 - 4/7
+ 4/9.....) pofonegyszerű programot írni számológépen."

Sanyi, Tolosa !
Rájöttem valamire a Leibniz-sorozattal kapcsolatban ami szerintem
benneteket is érdekelni fog. A függvénygörbéből is látszik hogy
állandóan alá-fölé lövöldöz a pi-nek. Páros számnál alá, páratlannál
fölé.
Ha lefuttatjuk egy páros és a mellette lévő páratlan számra majd az
alsó értékhez hozzáadjuk a két eredmény különbségének a felét, akkor a
hibát megfelezzük.

Vagyis:
Leibniz(páros)->alsó
Leibniz(páros+1)->felső
π= alsó+(felső-alsó)/2

Például Tolosa képleteivel (a TI ∑ és ∏ utasítását használva):

Wallis(10000)= 4 tizedes, 3' 30''
Leibniz(10000)= 3 tizedes, 2' 20''
De (!)
Leibniz(5000)= 3 tizedes, 1' 20'' (alsó)
Leibniz(5001)= 1' 20'' (felső)

π= alsó+(felső-alsó)/2= 7 tizedes pontosság !

Végül is ez csak egy ötlet, de úgy néz ki hogy működik. Így a Leibniz
már gyorsabb mint a Wallis.

[tolosa]

Hogy Te miket fedezel fel!?:-)
Holnap kipróbálom.

[Sanyi]

Köszi Pipás a pi közelítő TI programot, publikáltam is a blogban ;)

[tolosa]

Kedves Sándor!

Névnapod alkalmából nagyon sok boldogságot kívánok!:-)

[Sanyi]

Nagyon szépen köszönöm ;)
Én elég szórakozott vagyok, így ne haragudj(atok) majd, ha véletlenül
elfelejtem az ilyesmit.
Sőt, le is maradtam, pont most nézem hogy Neked is nemrég volt Tolosa
- Boldog Névnapot Neked is, így utólag ;)

[tolosa]

Köszönöm én is, de nem provokációnak szántam ám!:-)))

[Sanyi]

Tudom ;)
Egyébként már csak kilencet kell aludni, és egy éves a Számológép
Fórum ;)

[tolosa]

Ahhoz képest, hogy ilyen fiatal a fórumod, a Google számtalan
találatot mutat vele /és persze a neveddel/ összefüggésben/.
Néha, amikor számológép-viszonylatban keresgélek valamit, szinte
minden link előbb-utóbb ide vezet.:-)

******

Úgy tűnik, azért a jó öreg Arkhimédész módszerénél nem nagyon van
gyorsabb formula a PI közelítő értékének számításához.:-)
Arkhimédész az egységsugarú kör köré írható érintősokszög kerületének
kiszámításával becsülte meg a PI értékét.
A levezetések utáni képlet:

K /kör/ = n* tg(180°/n)

-ahol n értékének növelésével fokozható a PI értékének pontossága.

n=10000-nél /ami zsebszámoló számára egy mérhetetlenül rövid
pillanatig tart/ már 6 értékes és pontos tizedesjegyet kapunk.

[tolosa]

A témához kapcsolódó link:

http://www.freeweb.hu/t-t/minden/tudom/pii01.htm

[tolosa]

Persze azért manuálisan más dolog lehetett vele számolgatni abban az
időben, amikor a trigonometrikus értékek nem álltak elő egy
gombnyomásra!:-)

[Sanyi]

Köszi a linket Tolosa.
Ami a fórumot illeti, igen, valóban elég fiatal - de remélem, még
sokáig fog élni, és hasznos forrás lesz akár saját magunknak, akár
másoknak, akiket érdekel ez a téma (a Számológép Blogot egyébként egy
kicsit korábban létrehoztam, azt már 2008. augusztusában elindítottam
- igaz, az sem volt még olyan rég;))
Visszatérve a pi-re, épp most találtam egy jópofa karikatúrát :)
http://ludolph-pi-3-1415.blogspot.com/2010/03/pi-karikatura.html

[Pipás]

Én is boldog névnapot kívánok Neked is Sanyi, és utólag Neked is
Tolosa!

[Sanyi]

Köszi szépen Pipás!
Megírtam a Leibniz-sorozatos programot a Casio-mra (egy cikuls az
egész, szerintem 200 byte sincs az egész program), és most futtatom.
Már vagy negyed órája megy, 16800 felett jár a ciklus, de még csak
3,22759....-nél tart a közelítés :)

[Sanyi]

Hmm.. bár valamit elronthattam, mert ennél azért jobbnak kellene
lennie... :)

[Sanyi]

Ok, megvan, kicsit elírtam pár konstanst.... :)
Így már mindjárt más, 280 körül jár a ciklus, és már kihozta a 3,14-
et.... :)

[Pipás]

Várjál mindjárt felteszek valamit ! :-)

[Litauszky György]

Arkhimédész  módszere az igazi, de az új jelszó a Newton formula. Megnéztem a Tical.org-on talált programot, az relatív dolog hogy lassú.

http://www.ticalc.org/archives/files/fileinfo/388/38855.html

 Eddig ez a leggyorsabb módszer amivel találkoztam. 20 számjegyet a Plusszon 1 perc 10 másodperc alatt számol ki, az eredményt listában számjegyenként tárolja.

Ezért fogtam magam, bemásoltam a programlistát az Nspire emulátorba, addig igazgattam még futni nem kezdett rajta. Most felteszem a fórumra így Ti is ki tudjátok próbálni.

 A Pidoc.tns-t kell megnyitni  a File*>Open document... menüponttal. Futtatás: nspi(számjegyek száma). Írjátok meg sikerült-e a dolog.

Az emulátoron villámgyors, kíváncsi vagyok hogy futhat az igazi kalkulátoron.

 

A programlista is olvasható a dokumentumban, habár a kommenteket kiszedtem belőle. Szerintem ügyes program.

 

Pi közelítő program TI-Nspire, Os 2.0:

Pidoc.tns

[Sanyi]

Hmmm, ez aztán a csemege ;) Köszi szépen, holnap átbogarászom.

[tolosa]

Szia!

Valódi gépen lefuttattam...hááát...nagyon lassú.50 tizedesjegyet.60 mp
alatt állít elő. Először azt gondoltam, hogy a "dislay" utasításhoz
szünet van hozzárendelve /na, ezt ki is próbálom, hogy kiveszem a
kijelzést, elég,ha a végén teszi/, de nem.
Viszont tény, hogy ez a első program /az itt tárgyaltak közül/,
amelyik kalkulátoron állítja elő a PI számjegyeit.

Köszi, hogy közzétetted!

On márc. 18, 19:36, Litauszky György <litauszky_gyo...@t-online.hu>
wrote:
> Arkhimédész  módszere az igazi, de az új jelszó a Newton formula. Megnéztem a Tical.org-on talált programot, az relatív dolog hogy lassú.http://www.ticalc.org/archives/files/fileinfo/388/38855.html

>  Eddig ez a leggyorsabb módszer amivel találkoztam. 20 számjegyet a Plusszon 1 perc 10 másodperc alatt számol ki, az eredményt listában számjegyenként tárolja.
> Ezért fogtam magam, bemásoltam a programlistát az Nspire emulátorba, addig igazgattam még futni nem kezdett rajta. Most felteszem a fórumra így Ti is ki tudjátok próbálni.
>  A Pidoc.tns-t kell megnyitni  a File*>Open document... menüponttal. Futtatás: nspi(számjegyek száma). Írjátok meg sikerült-e a dolog.
> Az emulátoron villámgyors, kíváncsi vagyok hogy futhat az igazi kalkulátoron.
>
> A programlista is olvasható a dokumentumban, habár a kommenteket kiszedtem belőle. Szerintem ügyes program.
>
> Pi közelítő program TI-Nspire, Os 2.0:
> Pidoc.tns
>

>  pikep.jpg
> 97KMegtekintésNézet
>
>  Pidoc.tns
> 7KMegtekintésNézet

[tolosa]

Sajnos nem nagyon jött be a dolog. Kiiktattam a köztes eredmény
kijelzését -ezáltal egy IF-Then-EndIF hurok is kiktatva lett- de csak
5 másodpercet nyertem vele.

Szóval a valódi TI-Nspire gépen lassú a dolog.
Nem tudom, hogy az emulátoron van-e lehetőség a valós sebesség
beállítására. A HP-emulátornál kiválasztható, hogy a kalkulátor valós
sebességét is emulálja.

[tolosa]

Most olvasom, hogy a TI-Plus gépen 20 elemet 1 perc 10 másodperc alatt
számol ki.
Akkor lehet, csak nekem tűnt lassúnak a folyamat?
Persze igaz lehet, mert mihez képest is tartom én lassúnak?

[Pipás]

Hááát... ide teszek egy idézetet:-)

"10000-es felső korláttal számolva már jelentősen megnő a számolási
idő
-úgy 2 percre saccoltam- és a végeredmény:3.14149265367. "

Ez a Leibniz formula volt a HP-n 3 tizedesre beépített függvénnyel.
Ahhoz képest jelentősen gyorsabb, nem? A PC-vel nem szabad
összehasonlítani, mert:
1. A PC-ben jóval nagyobb processzor van.
2. A futtatott program lefordított exe, tehát compiler-es., a
számítógép gondolkodás nélkül lefuttatja.
A kalkulátor programja interperter-es (értelmezős), vagyis pl. minden
ciklusnál annyiszor értelmezi az utasításokat, ahányszor a ciklus
lefut. Emiatt akkor is lassabban futna, ha ugyanazon a gépen lenne
mint az előző.

Az meg hogy a kiiratás kiiktatásával nem sok időt nyertél, csak azt
jelenti hogy jól átgondolt helyre tette a program írója.
Közben át-átkukucskálok nehogy összeadjunk. Látom már Te is
gondolkodsz rajta, tényleg olyan lassú-e? :-)

On márc. 18, 20:40, tolosa <tol...@freemail.hu> wrote:

[Sanyi]

Pipásnak köszönhetően (amiért "olvasható" formában elküldte a TI
forráskódot) sikerült Casio-ra ültetnem Cass Lewart nagyszerű pi
közelítő programját. Igaz, a Casio-n a listák mérete max 255 elem
lehet, így ez korlátot jelent, de amúgy tökéletesen működik a program.
Lényegében csak a változókat kellett átneveznem, mert csak egy
karakteresek lehetnek, és a két tömböt is List 1-nek és List 2-nek
neveztem át.

[Pipás]

Örülök hogy ilyen gyorsan sikerült a dolog. :-)
Közben én is nézegettem a programot, és azt vettem észre hogy az
utolsó tizedesjegy nem mindig pontos.
Például:
10 számjegy: 3.1415652 , a 2 eggyel kevesebb.
11 számjegy: 3.14156535 , ez végig pontos.
Valamint a tizedespont előtti "3" is beleszámít a kijelzett számjegyek
számába.
Tehát a Plusszom végül is nem 20, hanem csak 18 tizedesjegyet számolt
ki 70 másodperc alatt. De még így is összehasonlítva az eddig próbált
módszerekkel az én gépemen mérve:

Leibniz: 2 tizedes 35 sec= 17.5 sec/számjegy
3 tizedes 140 sec= 46.6 sec/számjegy, lassul.
Wallis: 4 tizedes 210 sec= 52.5 sec/számjegy
Newton: 18 tizedes 70 sec= 3.8 sec/számjegy

Így nálam a Newton formula Basic programban futtatva és listát
készítve a beépített függvényt használó Leibniz(∑) formulánál 4.6-szor
és 12.3-szor, a Wallis(∏) képletnél 13.8-szor gyorsabb. Persze azért
új világcsúcsot nem fogunk vele felállítani. :-)
Ezek természetesen nem pontos mérések, nem tudni hogy változna a dolog
több tizedesjegynél.

[Litauszky György]

Egy lavinát indítottál el Tolosa, amikor elkezdted a pi értékét közelítgetni az Nspire gépeden. Itt egy újabb megoldás:

Csak piszkálta a csőrömet az a link amit Sanyi tett fel a TI-89 -el kapcsolatban, valamint az is hogy ezt a feledatot a sok ciklus miatt nem igazán Basic-ben kell(ene) megoldani.

http://www.ticalc.org/archives/files/fileinfo/397/39731.html

Ez a program C-ben van. Azt írja a szerzője hogy szerinte simán futna Plusszon is ha úgy lenne lefordítva. Simán átnevezve a programot 89z- ről 9xz-re a Plussz idegen kalkulátor hibát írt ki.

A pi.c forráskódot megnyitva láttam hogy a programot a tigcc fejlesztői környezettel fordították.

http://www.ticalc.org/archives/files/fileinfo/118/11873.html

Ezt feltelepítve a forráskódban csak egy sort kellett átjavítani:

Ezt: "#define USE_TI89"  erre:  "#define USE_TI92PLUS "

Utána parancssorból a "tigcc -O3 -Wall pi.c" utasítást kiadva létrejött a pi.9xz állomány ami a Pluszra feltöltve simán és (kalkulátorszinten) gyorsan fut.

Én még nem mértem időt a Plusszon, csak azt láttam hogy gyors. Ideteszek néhány futási adatot a pi.txt-ből:

 

# digits:    Time (HW 2.00 TI-89):    Time (HW 4.00 TI-89 Titanium):

   100            1 sec                                  1 sec

   500           16 sec                               15 sec

  1000          56 sec                               54 sec

  2000         211 sec ( ~3.52 min)        203 sec ( ~3.38 min)

  4000         812 sec (~13.53 min)       785 sec (~13.08 min)

  4676        1104 sec (~18.40 min)    1067 sec (~17.78 min)

 

Szóval igazad volt Tolosa, tényleg lassú az előző program, dehát az Basic-ben van.

Felteszek egy képet és a lefordított programot is hátha valaki hasznát veszi, habár ebben a formában csak Plusszra jó.

[Pipás]

Egyébként Travis Evans a fenti programot a következő link alapján
írta:
http://www.codecodex.com/wiki/index.php?title=Digits_of_pi_calculation#C
Itt a pi megközelítése több programnyelven megtalálható. A Bacis
részben még a formula is megvan, megpróbálom idemásolni.

∞ 16(-1)^(k+1) ∞ 4(-1)^(k+1)
π = ∑ ----------------------- - ∑ ------------------------
k=1 (2k-1)5^(2k-1) k=1 (2k-1)239^(2k-1)

Nem jött össze a másolás, maradt a bevált módszer. :-) Beírva a gépbe
ez is gyors. Mondjuk lassabb mint a program és csak annyi tizedest
lehet megnézni, amennyit a kalkulátor képes ábrázolni. (13
tizedesjegy= 2 másodperc)

[Sanyi]

Egyszerűbb és kevésbé tudományos eredmények ugyan, de készítettem én
is
egy-két újdonságot :)
Cass Lewart programjának átdolgozása után írtam egy listázót is, ami a
képernyőre varázsolja az első 145 (21*7-2) tizedesjegyet:
http://szamologep.tumblr.com/post/463348450/pi-jegyek-casio-n

Valamint véletlenszámokkal és egy egyszerű algoritmussal rajzoltam
egy szép pi-t:
http://szamologep.blogspot.com/2010/03/muveszi-pi-szimbolum-casio-gra...

[Sanyi]

A második linket elírtam, itt a jó:
http://szamologep.blogspot.com/2010/03/muveszi-pi-szimbolum-casio-grafikus.html

[Pipás]

Jól néz ki a pi, és a 145 tizedesjegy sem semmi. Úgy tapasztalom nem
maga a kiszámolás az izgalmas, hanem a "nekifutás", ha érted hogy mire
gondolok. :-)

On márc. 21, 16:50, Sanyi <cs...@freemail.hu> wrote:
> A második linket elírtam, itt a jó:http://szamologep.blogspot.com/2010/03/muveszi-pi-szimbolum-casio-gra...

[Sanyi]

Köszi :) Így igaz, a nekifutás, az "út" is fontos dolog.
A pi-kiszámoló programot a Casio nyelvének sajátosságait kihasználva
sikerült tömörítenem is egy kicsit, azt hiszem olyan 540 byte volt
eredetileg, és kb 470-re sikerült lefaragnom.
Ha megnézed az "átmenetes pi" rajzoló forráskódját pl. (
http://szamologep.blog.hu/2010/03/21/pi_szimbolum_grafika ), a => jel
egy "if then ifend" elágazást tömörít (kettős nyíl szimbólum a
kalkulátoron, csak így sikerült ASCII-be átírnom).
Feltétel => utasítás alakban működik, viszont csak egy utasítás állhat
utána.
A feltételeket pedig akár zárójelezni is lehet, bár oda AND-eket is
rakhattam volna.
(Az Isz pedig inkrementálás, növeli 1-el a változó értékét, Dsz pedig
csökkenti).

[Pipás]

:-)
Ezért nem sikerült eddig eligazodnom rajta igazán. Most majd megint
átbogarászom.

On márc. 21, 20:24, Sanyi <cs...@freemail.hu> wrote:
> Köszi :) Így igaz, a nekifutás, az "út" is fontos dolog.
> A pi-kiszámoló programot a Casio nyelvének sajátosságait kihasználva
> sikerült tömörítenem is egy kicsit, azt hiszem olyan 540 byte volt
> eredetileg, és kb 470-re sikerült lefaragnom.

> Ha megnézed az "átmenetes pi" rajzoló forráskódját pl. (http://szamologep.blog.hu/2010/03/21/pi_szimbolum_grafika), a => jel

[Sanyi]

A program "lelke", "trükkje" egyébként a véletlenszámokban rejlik,
azokkal oldottam meg a "színátmenetet", azaz a lerakott pixelek
sűrűségének változását. Pl. azt mondom, hogy vegyen egy véletlenszámot
(y koordinátának pl.), majd még egyet ("ritkító-tényezőnek"), és csak
akkor tegyen az adott helye egy pontot, ha a véletlenszám (y) kisebb,
mint a ritkító-tényező. Így belátható, hogy 0-hoz közeli jóval több
lesz, mint 1-hez közeli, mivel a ritkító leszabályozza. Itt a jobb,
kevésé lineáris átmenet érdekében 3 "ritkító" véletlenszámot is
használtam.
(sajnos ez - sem - saját ötlet, valamikor nagyon régen olvashattam
róla egy basic-es könyvben [volt régen egy basic-nyelvjárásos
könyvsorozat, nagyon szerettem, sokat kihoztam belőle a könyvtárból],
de szeretem alkalmazni, mert látványos dolgokat lehet vele
előállítani).

[Sanyi]

(reagálva Pipás egy hozzászólására, amit most nem találok)

Pipás, való igaz, nem kell mindig a "kályhától" elindulni, mert akkor
tényleg nem nagyon haladna a fejlődés.
De jó érzés felfedezni a dolgokat, ezért irigylem a nagy
felfedezőket :)
És a Code Codex linket is köszi, eddig nem ismertem az oldalt:
http://www.codecodex.com/wiki/Digits_of_pi_calculation

[Pipás]

Hát leszedtem, mert újra akartam fogalmazni, de végül is akkor már
olvastad. :-)

[Sanyi]

Olvastam, és tényleg nagyon jó ez a "kódkódex" :)
Visszatérve kicsit ezekre a véletlenszámos "átmenetekre", TI-92-n még
látványosabbak lennének, a nagyobb és pixelgazdagabb kijelző miatt.
;)

A pi-rajzoló programot megfogalmaztam általánosan:

Képernyőtörlés;
Grafikus ablak: xmin=0, xmax=1.75 , ymin=0, ymax=1;
P legyen 0;

Ciklus: M legyen 1, és menjen egyesével jó sokáig (pl. 22500-ig)

X legyen 1.75*random;
Y legyen random;
S legyen 1;

Ha x > 0.25 és X < 1.5 és Y < 0.688 és Y < 0.937 akkor S legyen 0;
Ha x > 0.5 és X < 0.75 és Y < 0.063 és Y < 0.937 akkor S legyen 0;
Ha x > 1 és X < 1.25 és Y < 0.063 és Y < 0.937 akkor S legyen 0;

Ha S = 1
Akkor
B logikai változó legyen, az hogy (random > Y)
C logikai változó legyen, az hogy (random > Y)
D logikai változó legyen, az hogy (random > Y)
különben
B logikai változó legyen, az hogy (random < Y)
C logikai változó legyen, az hogy (random < Y)
D logikai változó legyen, az hogy (random < Y)
Elágazás vége

Ha B igaz és C igaz és D igaz
Akkor
rajzold ki az X,Y képpontot
növeld 1-el a P változót (ami csak arra kell, hogy hány képpontot
rajzolt már ki)

Ciklus vége

[Pipás]

Kösz, kipróbálom. Így már 3 infó van hozzá.

[Litauszky György]

Sanyi, lefuttatam a pi-rajzoló programot, sajnos nem lett látványosabb a kép. A fő ok az hogy a Plusz képfelbontása csak vízszintesen nagyobb. A Casioé 175*100, a Plussszé 238*102. Így csak vízszintes irányban tudtam széthúzni szegény pi-t, meg egy kicsit megvastagítottam a szárait. Így már inkább egy hídra hasonlít. (Nem lehet a levélbe mosolygást tenni, mert külön tölti fel a Google a képek közé.)

A futásidő 1 ó 24 p 47 mp (!) volt, plussz a próbálkozások. 3755 pontot rakott ki de jobban elnyútva, ezért a Te képed kontrasztosabb.

Idemásolom a programlistát is, így össze lehet hasonlítani a két gép programnyelvét. A Plusszon csak sima IF..Then.. Else.. Endif szerkezet van és a When(feltétel, igaz, hamis) utasítás. A futásidőt az OS 2.09 beépített órájával mértem.

off

Ez a Plusz utólsó operációs rendszere (2003/03/27) hasonló a Voyage 200-éhoz. Át lehet váltani ikonos menüre (én nem használom), erről is felteszek egy képet.

on

 

\START92\
\COMMENT=
\NAME=randpi
\FILE=RANDPI.9XP
()
Prgm
 Local p,x,y,s,a,b,c
 ClrDraw
 startTmr()\->\kezd
 0\->\p
 For m,1,22500
   rand(238)\->\x
   rand(102)\->\y
   1\->\s

 

   If x>30 and x<208 and y>6 and y<36
     0\->\s
   If x>60 and x<90 and y>6 and y<94
     0\->\s
   If x>148 and x<178 and y>6 and y<94
     0\->\s

 

   If s=1 Then
     when(rand(102)>y,1,0)\->\b
     when(rand(102)>y,1,0)\->\c
     when(rand(102)>y,1,0)\->\d
   Else
     when(rand(102)<y,1,0)\->\b
     when(rand(102)<y,1,0)\->\c
     when(rand(102)<y,1,0)\->\d
   EndIf
   If b=1 and c=1 and d=1 Then
     PxlOn y,x
     p+1\->\p
   EndIf
 EndFor
 checkTmr(kezd)\->\veg
EndPrgm
\STOP92\

[Pipás]

Most látom hogy fordítva van árnyékolva a kép. Először a pi is fejjel
lefelé volt. :-)

[Sanyi]

Azért nem néz ki rosszul ez a pi sem ;) Nálam is nagyon sokáig tartott
a futás, órákig futtattam (pontosan nem is tudom, meddig).
Köszi a képernyőképeket!

[Sanyi]

Egy kicsit off, mert csak "szimbolikusan" kapcsolódik a pi-hez,
de... :)
http://ludolph-pi-3-1415.blogspot.com/2010/03/rubik-pi.html
http://ludolph-pi-3-1415.blogspot.com/2010/03/pi-bugyi-masni-egy-fehernemubolt.html