[BC6] Int die met grotere getallen werkt...

[Verwijderd]

Ik heb voor mijn programma een type nodig dat tot 2^500 (lekker groot ) op een eenheid (1) nauwkeurig kan rekenen. Dus als ik 2^500-1 doe, dan moet er ook echt 2^500-1 uitkomen. Ik heb er wel even na gezocht en ik weet dat er in JAVA zoiets bestaat (vergeten hoe het heet(BIGINT, dacht ik), maar die is niet meer precies dacht ik na verloop van tijd. En bovendien is C++ veel sneller. Het is dus heel belangrijk dat hij precies is.

[Glimi]

code:

Type    Suffix  Example         Storage
__int8  i8  __int8 c = 127i8;           8 bits
__int16 i16 __int16 s = 32767i16;           16 bits
__int32 i32  __int32 i = 123456789i32;      32 bits
__int64 i64 __int64 big = 12345654321i64;   64 bits
unsigned __int64    ui64    unsigned __int64  hugeInt =     64 bits

In de help van BCB4, dus waarsch ook in BCB6 zo

[edit] Idd, kvdveer, ik let weer niet op. Idd is 2^64 bij lange na niet 2^500'ste
Alleen vraag ik me af waar die precisie voor nodig is bij zulke getallen

[ Voor 20% gewijzigd door Glimi op 24-01-2003 20:52 ]

[kvdveer]

Hugeint kan nog steeds geen 2^500 bevatten hoor.
je zult met een soort van bigint-class aan de gang moeten. Ik ben niet bekend met BCB, maar ik verwacht wel dat dit soort klassen bestaand - desnoods custommade.

[TD-er]

mischien handig als je enigzins je probleem kunt omschrijven.
Mogelijk namelijk dat je helemaal geen ultra-mega-huge-ints nodig hebt.
Ik heb wel eens een puzzeltje uitgeprogrammeerd en daarmee tot waardes van ~ 10^500 (is in orde 2^1500) zitten doorrekenen. en door slimme eliminatie een hele hoop mogelijkheden uit kunnen sluiten.
Ik heb hiervoor gewoon een array gebruikt met int's en wat slimme procedures geschreven (nav. online gevonden vergelijkbare procedures, die op strings met hex-waardes werkten) voor +, -, * en /
Ik denk dat dat toch wel het makkelijkste is, de benodigde procedures zelf ff schrijven, zolang het gaat om eenvoudige operaties en niet bijv sin, cos, log, wortel enz.

[Pooh]

Ik denk dat je hier wel wat aan hebt? http://www.ginac.de/CLN/

[Verwijderd]

Ik wil deze preciesie gebruiken om in een zeer grote zoekruimte (2^1000 ongeveer) grote stappen te maken. Ik heb een manier bedacht om met een bepaalde waarschijnlijkheid bepaalde stappen te maken, zodat alleen betere oplossingen gevonden worden, tenminste dat is het idee...

Ik ben CLN nu aan het downloaden.

[Verwijderd]

Ik heb hem gedownload en ik heb de manual voor het belangrijkste deel gelezen en ik zie dat ik GNU g++ nodig heb. Het kan ook zijn dat ik het gewoon met BC6 kan doen, maar dat zie ik er niet bij staan. Ik zie allerlei commando's staan, zoals Make enz. Ik zou denken dat dat ook gewoon met BC6 zou moeten kunnen. Als je compiled, dan make je hem in principe ook. Maar als ik al die dingen allemaal apart moet gaan compilen, ben ik eeuwig bezig. Weet iemand hoe ik er gewoon voor kan zorgen dat ik snel die CLN-lib kan gebruiken?

[LordLarry]

Of gebruik BCD (binary-coded decimal http://www.tpub.com/neets/book13/53s.htm). Een implementatie hiervan zit standaard bij BCB.

[Apache]

Er is een GNU lib (http://www.gnu.org/directory/libs/gnump.html) die met grotere getallen kan werken.

Misschien als het niet perse in BC6 moet kan je overstappen naar haskell die zulke dingen makkelijk aankan en ook andere geile dingen kan

code:

Prelude> 2^500
32733906078961418700131896968275991522166420460430647894832913680961337964046745
54883270092325904157150886684127560071009217256545885393053328527589376

Zelfs dingen als (2^4096)^10 doet hij gemakkelijk, enkel delingen met grote getallen etc geeft hij snel #.INF

[Verwijderd]

Handig dan dat ik Haskell over een paar maanden leer, jammer dat het pas over een paar maanden is. Ik ben die andere lib nu ook aan het downlaoden. Vraagje: Kun je met Haskell eigenlijk wel connecten met een DB? Waarschijnlijk wel, maar bestaan er nog geen drivers voor, of wel?

[Verwijderd]

TD-er schreef op 24 januari 2003 @ 20:54:
mischien handig als je enigzins je probleem kunt omschrijven.
Mogelijk namelijk dat je helemaal geen ultra-mega-huge-ints nodig hebt.
Ik heb wel eens een puzzeltje uitgeprogrammeerd en daarmee tot waardes van ~ 10^500 (is in orde 2^1500) zitten doorrekenen. en door slimme eliminatie een hele hoop mogelijkheden uit kunnen sluiten.
Ik heb hiervoor gewoon een array gebruikt met int's en wat slimme procedures geschreven (nav. online gevonden vergelijkbare procedures, die op strings met hex-waardes werkten) voor +, -, * en /
Ik denk dat dat toch wel het makkelijkste is, de benodigde procedures zelf ff schrijven, zolang het gaat om eenvoudige operaties en niet bijv sin, cos, log, wortel enz.

Had ik ook aan gedacht, maar ik ben niet van plan om het wiel opnieuw uit te vinden om alleen maar een idee te testen.

[mbravenboer]

Ik heb er nog nooit mee gewerkt, maar dit zou wat moeten zijn:

http://www.haskell.org/libraries/#interfacingDataBases
http://www.haskell.org/haskellDB

Dit zaakje is ontwikkeld door Daan Leijen, iemand die bij de Universiteit Utrecht zit.