Krachtig Wiskunde-Programma
 

Ik ben op zoek naar een zeer krachtig Wiskunde-Programma...Ik heb maple reeds geprobeerd maar maple kan slechts getallen van 268435448 digits aan; Ik zoek een programma dat bijvoorbeeld een miljard getallen aankan of misschien iets meer; het maakt mij daarbij niet uit snel het programma is, als het maar geen jaren hoeft te duren;
om er een legitieme vraag aan te verbinden
hoe werkt een programma in godsnaam met getallen groter dan 1000 strings aan elkaar?

volgens mij zijn op dit moment maple en mathematica wel ongeveer de programma's die veel gebruikt worden...

wat moet een mens ook met meer dan 268435448 digits?????

En vergeet MATLAB niet, dat ook veelvuldig wordt toegepast.

Ik denk door middel van bit-shifting

Hoeveel digits kan ik daar inproppen?

Kun je me daar meer over vertellen?

Tuurlijk...

Maar wat bedoel je met digits? Gehele getallen?

De beste (enige) programma's die ik ken zijn maple, matlab en derrive. En deze vind ik toch meer dan krachtig genoeg voor normale berekeningen.

Waarom probeer je zelf 'ns niet iets te programmeren voor je probleem?

Het aantal digits van een getal, is het aantal getallen waaruit een getal bestaat
bijvoorbeeld getal: 6.000.000 heeft 7 digits
en nu wil ik graag tot 1 miljard digits :D

Gisteren bij Mathematica kon ik hem het getal 10^1,000,000 laten representeren (weet eerlijk gezegd niet of hij er ook mee kon werken); de grootte van getallen is daar beperkt tot hoeveel geheugen je hebt.

Maar hoeveel digits heeft hete getal 2.25 dan?
1? of 3?

Ik ga even uit van 1, zodat ik bit-shifting even uit kan leggen... :)

Bits, nibbles en bytes:
Een bit kan een 0 of 1 bevatten.
4 bits vormen een nibble.
2 nibbels vormen een byte, dus heeft een byte 8 bits.

Het verband tussen hex en binair:
Hex staat voor 16.
Een byte heeft 256 waarden, en laat dat nu net 16^2 zijn :)
Een hex getal staat dus voor een nibble :)

Om om te rekenen van binair naar hex, kun je het volgende doen:
Neem 00110010b.
Verdeel dit in 2 nibbles: 0011b en 0010b
0011b = 3
0010b = 2
Dit levert in hex het getal 32 op :) sim-pel.

Bit-shifting
Het volgende verhaal is ter illustratie; werkelijke groottes van de CPU registers zijn anders

Een CPU heeft registers. Dit ga ik nu niet allemaal uitleggen ;), maar een daarvan is register AX.
Laat dit register 1 byte groot zijn. AX in onderverdeeld in AH (high order bit) en AL (low order bit).
In dit voorbeeld zijn AH en AL nibbels (de helft van een byte).

AX = AHAL

Wanneer in AX 0000 0001b staat, staat in AL 0001b en in AH 0000b.

STEL dat we niet verder kunnen rekenen dan 0Fh., maar wel getallen groter dan 0Fh weegeven ;)

We willen 9 + 9 uitrekenen. Hoe doen we dit?

Op de volgende manier:
AX = 9 = 0000 1001b --> AH = 0000b en AL = 1001b

We schuiven de bits in AX 2 naar links, oftewel SHL AX, 2. SHL staat voor SHift Left. We schuiven 2, omdat dat de helt is van het aantal bits in een nibble; wanneer we 4 zouden gebuiken, zouden we het hele register overzetten, waar we dus niks aan hebben. :)

Nu staat in AX: 0010 0100b (= 24h)
Met in AH 0010b en in in AL 0100b

Nu schuiven we AL twee naar rechts (SHR AL, 2):
AL = 0001b

Nu doen we AH + 0010b en AL + 0001b (we schuiven het getal waarmee we optellen ook op dezelfde manier, in een ander register).

Dit levert
AH = 0100b
AL = 0010b
AX = AHAL = 0100 0010b

Om het goede getal te krijgen, moeten we alles weer omgekeerd terugschuiven:

SHL AL, 2
SHR AX, 2

AX = 0001 0010b
AH = 0001b
AL = 0010b

In AX staat nu 12h, en dat is 1 * 16^1 + 2 * 16^0 = 18d, en dat klopt!
En zo hebben we goed rekent met meer getallen dan we aankunnen... :)

Tja.. dit is bit-shifting in het kort.
Hopelijk snap je het! :D :D ;)

ik wil graag dat hij mijn hd als cache gebruikt

maar een 1 met een miljoen nullen erachter is wel geil ja :D :D

ja eddie dat begrijp ik wel :)
ik ben een gematigd programma cracker dus ik weet er wel iets van :D
maar ik wist niet hoe dit ging
nice! :D

Als 't goed is zal Mathematica je swap-file automatisch gaan gebruiken; ik had m'n swapfile op een statische grootte gezet, misschien dat je een nog groter getal kan verwerken als je virtueel geheugen dynamisch is ingesteld.

hmmmmmm,
Ik persoonlijk zweer bij DERIVE......
past op 1 diskette

Ja die programma's hierboven zijn de enige betaalbare (maple uitgezondert of je moet de proefversie nemen) toen ik een onderzoekje heb gedaan voor pi schreef hij alles automatisch weg naar mijn HD, daar schrok ik eerst van want dat loopt al snel in de enkele giga bytes als je met grote getalen werkt. Maar wat wil je dan onderzoeken, want het lijkt me sterk dat je echt zo'n giga getallen wilt gebruiken.

ik heb er geen verstand van ofzo, maar wij gebruiken altijd mathcad.

3. want ik denk dat al die programma's wel x * 10^100000000000000000 mee kunnen rekenen, maar het aantal getallen bij x achter de komma dan beperkt is tot zoveel miljard.

3 * 10^1000000000000000000 is namelijk volgens mij maar 1 digit, en daar kan hij wel mee rekenen, denk ik.

Hoe kom je erbij dat 3 * 10^1000000000000000000 maar 1 digit is??

Mja dat zijn er een stuk of 3 en nog een enorme macht van 2...

ehm... als je een getal wilt hebben met een miljard digits... dan kom je als aan een antwoord van 1000 MB... om op te slaan... dan heb ik het nog niet eens over het bereken... (dat een paar dagen duurt)

Zie The Art Of Assembly voor veel info over... assembly en consorten :)

En voor hoe die wiskunde programma's werken... zoals ik al zei met bit-shifting, en ik denkt teven met data opslag.

Stel dat ze niet verder kunnen erkenen dan 32 bits. Wanneer de verder willen gebruiken ze dus bit-shifting, en wat ze 'eruit' shiften, kunnen ze in een andere plek op het geheugen zetten. Of in een tekstbestand... :)

Wanneer ik assembly kan, zal ik wel eens proberen zo'n programma te schrijven (dit zal wel lang duren :D) :)