[C++] Oneindig groot getal

[iets]

Ik ben recentelijk begonnen met C++ en ik probeer op het moment een benchmark programma te maken zoals PiFast.

Ik loop nu alleen tegen twee problemen aan:

- Om het resultaat van Pi te laten zien gooi ik de waarde van Pi in een long double. Deze ondersteunt echter maar 17 getallen achter de komma. Dus na een tijdje kan de Pi niet meer preciezer worden weergegeven. Ook wordt er in de berekening gebruikt gemaakt van een getal dat steeds kleiner wordt naarmate Pi preciezer wordt uitgerekend. Dit getal moet dus ook een 'oneindige waarde' kunnen aannemen.

- Om te kijken hoe lang de berekening geduurd heeft maak ik gebruik van time.h's functie: time(NULL). Helaas heeft ook die functie een maximale precisie van 1 sec, en ik millisecs nodig.

Mijn vraag is dus hoe ik de bovenstaande problemen kan oplossen .

[Nvidiot]

Zoek een BigInt op (of een bigLong ofzo ) en een GoT search zou wel wat topics moeten vinden over milisec timers, die heb ik al vaak voorbij zien komen.

[iets]

BigInt: https://sourceforge.net/projects/cpp-bigint/

Ik zal er eens wat mee prutsen tnx!

En op GoT valt niks te vinden over millisec timers. Wel genoeg topics om een functie te vertragen (sleep() )...

[lordsnow]

Je kan een BigNum of Multi-Precision library proberen. Zie:
http://www.google.com/sea...&q=C%2B%2B+BigNum+library

En het tweede probleem zou je op kunnen lossen met een Multimedia of High-Precision Timer. Zie:
http://www.google.com/sea...mer&btnG=Search&hl=en&lr=

[MSalters]

BigInt is natuurlijk niet direct bruikbaar, dan weet ik het antwoord al. Pi==3
Sowieso is voor benchmarken een milliseconde timer onzinnig.

[nIghtorius]

als je dat ding in windows maakt kun je met behulp van de "GetTickCount" functie een milliseconden timer maken.

[IJnte]

long long unsigned double ofzo Zo heb ik ook wel eens wat opgelost. C++ builder kent iig long long unsigned int. Dat is een extra, Extra grote int
Tip

[MSalters]

IJnte schreef op donderdag 03 maart 2005 @ 11:16:
Tip

Heeft 0,0f met C++ te maken.

[Sabbi]

Waarom niet gewoon de waarde van pi in een string gooien? Je bent neem ik aan toch iteratief bezig pi te bepalen dus dan is elke keer een mego long long double oid overschrijven ook niet echt simpel, gewoon elke keer de volgende decimaal erachter en gaan. of wat voor logaritme gebruik je?

[Soultaker]

Zo'n ding heet een algoritme maar verder heb je gewoon gelijk: gewoon direct uitprinten dat ding of opslaan in een string. Aan de andere kant, als je een algoritme gebruikt wat 'binaire' cijfers genereert is het misschien lastig dat on-the-fly te converteren. Maar als je een algoritme kunt begrijpen dat pi genereert, dan moet dat geen probleem zijn.

[ Voor 18% gewijzigd door Soultaker op 03-03-2005 14:55 ]

[RobIII]

Soultaker schreef op donderdag 03 maart 2005 @ 14:54:Maar als je een algoritme kunt begrijpen dat pi genereert, dan moet dat geen probleem zijn.

offtopic:
Hangt er van af hoe je pi berekent

Ik heb het zo wel eens gezien:

PI/4 = 1 - 1/3 + 1/5 - 1/7 + ...

[ Voor 7% gewijzigd door RobIII op 03-03-2005 15:19 ]

[MSalters]

Duh. Alle algoritmen die pi uitrekenen doen dat door termen te genereren die je bij elkaar moet optellen. Dan is het niet handig om de partiele som in een string op te slaan; twee strings kun je niet echt optellen.

[iets]

Bedank voor jullie reacties !

Mijn code op het moment is:

C++:

#include <iostream>
#include <math.h>
#include <iomanip>
using namespace std;

long double macht (long double getal, long double totdemacht);

int main()
{
    long double pi;
    long double a, b, c;
    long double aantalHoeken = 8;
    const float straal = 0.5;
    long double hvz = (sqrt (straal)) / 2;
    int aantalRuns;

    cout << "Voer in hoeveel runs je wil maken: ";
    cin >> aantalRuns;

    for (int i = 1; i <= aantalRuns; i++)
    {
        a = sqrt ((straal * straal) - (hvz * hvz));

        b = straal - a;

        c = sqrt ((b * b) + (hvz * hvz));
        
        aantalHoeken = 4 * macht (2, i);
        
        pi = c * aantalHoeken;
        
        hvz = (c / 2);

        cout << setprecision (25) << pi << endl << endl;

    }
    
    cin.get();
    cin.get();
    return 0;
}

long double macht (long double getal, long double totdemacht)
{
    if (totdemacht == 0)
    {
        return 1;
    }
    else
    {
        for (int z = 2; z <= totdemacht; z++)
        {
            getal *= 2;
        }

    return getal;
    }
}

Visueel:


hvz staat voor "helft vorige zijde".

Ik snap op het moment nog vrij weinig van die BigNum, maar daar moet ik nog wat meer aandacht aan besteden. Wel een hoop code is het .

MSalters schreef op donderdag 03 maart 2005 @ 11:04:
BigInt is natuurlijk niet direct bruikbaar, dan weet ik het antwoord al. Pi==3
Sowieso is voor benchmarken een milliseconde timer onzinnig.

En waarom is dat? Hoe wil je het anders meten?

IJnte schreef op donderdag 03 maart 2005 @ 11:16:
long long unsigned double ofzo Zo heb ik ook wel eens wat opgelost. C++ builder kent iig long long unsigned int. Dat is een extra, Extra grote int
Tip

Eehm een long double is al 80bit?

Sabbi schreef op donderdag 03 maart 2005 @ 14:52:
Waarom niet gewoon de waarde van pi in een string gooien? Je bent neem ik aan toch iteratief bezig pi te bepalen dus dan is elke keer een mego long long double oid overschrijven ook niet echt simpel, gewoon elke keer de volgende decimaal erachter en gaan. of wat voor logaritme gebruik je?

Zie code hierboven. Probleem is dat je bij het berekenen van Pi niet steeds een decimaal uitrekend maar de Pi steeds preciezer wordt uitgerekend. Je weet pas zeker dat een decimaal nauwkeurig is als het 3 of 4 berekeningen achter elkaar hetzelfde is.

RobIII schreef op donderdag 03 maart 2005 @ 15:14:
[...]

offtopic:
Hangt er van af hoe je pi berekent

Ik heb het zo wel eens gezien:

PI/4 = 1 - 1/3 + 1/5 - 1/7 + ...

Hmm die methode lijkt me idd wat handiger als dat nauwkeuig is .

[Verwijderd]

Is C++ noodzakelijk. Anders zou ik dergelijke algoritme-achtige dingen eerder maken in een functionele taal zoals Clean
Dat is een taal juist om efficient en makkelijk algoritmes te maken en je kunt er zonder problemen oneindig lange lijsten mee maken.

[MSalters]

Leuk dat je met Clean oneindig lange lijsten kunt maken. In C++ zitten die al standaard ( goh: header <list>, class std::list ). Plus, in de headar <algorithm> heb je al een hele zwik algoritmes zitten zoals de som van een lijst getallen.

Benchmarken doe je door code 1000x uit te voeren, en dan door 1000 te delen. Dan heb je dus automatisch milliseconde precisie als je met een seconde resolutie meet.

Je macht functie is defect; macht(4,2) is 2, niet 4. Bovendien is de code langzaam, en had je ook gewoon pow( ) kunnen gebruiken.

En de methopde van RobIII was bedoeld als voorbeeld hoe het niet moet. Nou niet vragen waarom, maar zelf bedenken svp.

[Soultaker]

edit: verkeerde topic.

[ Voor 92% gewijzigd door Soultaker op 03-03-2005 21:08 ]

[iets]

MSalters schreef op donderdag 03 maart 2005 @ 20:38:
Benchmarken doe je door code 1000x uit te voeren, en dan door 1000 te delen. Dan heb je dus automatisch milliseconde precisie als je met een seconde resolutie meet.

Dat zou kunnen maar dan doet de PC er dus 1000x langer over.

Je macht functie is defect; macht(4,2) is 2, niet 4. Bovendien is de code langzaam, en had je ook gewoon pow( ) kunnen gebruiken.

Haha dat is inderdaad een stuk handiger. Sorry dat ik van dit soort dingen niks afweet en dat mijn code er misschien nogal gaar uitziet. Maar ik ben pas 3 weken met C++ bezig en het boek waar ik mee werkt heeft nog niet eens strings behandeld .

Die pow( ) functie heeft wel een erg klein bereik trouwens. Met mijn eigen 'defecte' machts functie kon ik Pi nog uitrekenen tot +/- 500 runs. pow( ) stopt er al mee bij 30 runs.

En de methopde van RobIII was bedoeld als voorbeeld hoe het niet moet. Nou niet vragen waarom, maar zelf bedenken svp.

Ik zal m'n best doen .

[ Voor 13% gewijzigd door iets op 04-03-2005 00:41 ]