3. den Fortschritt eines ssseeeeehhhhhrrrr langen Prozesses speichern

den Fortschritt eines ssseeeeehhhhhrrrr langen Prozesses speichern

  • E

    hi,
    ich möchte den Fortschritt eines Prozesses der von 0 bis 2^2000 geht speichern. Hat da jemand Vorschläge?

    Mir ist bis jetzt nur ein ziemlich aufwendiger Weg eingefallen.
    Man legt eine Menge von Integern an.
    Man beginnt damit I1 hochzuzählen, läuft I1 über wird I2 um Eins erhöht, und so weiter bis I2 auch überläuft, jetzt wird I3 um eins erhöht und so weiter....

    thxia

    0
  • C

    Was meinst du mit "Fortschritt" und "Prozess" in diesem Zusammenhang (ich kenne die üblichen Definitionen, aber atm sehe ich nicht, was die mit deinem Beitrag zu tun haben).

    Wenn du 'nur' mit übergroßen Zahlenbereichen hantieren willst, solltest du mal nach GMP suchen - das ist eine Spezialbibliothek für (fast unbegrenzt) große Zahlentypen.

    0
  • H

    Hsllo,
    selbst wenn dein Prozess nur aus dem Inkrementieren eines Riesen-Integers besteht, wirst du in deiner Lebensspanne 2^2000 nicht erreichen.

    0
  • E

    eine Lib wollte ich nicht nehmen, weil ich damit überhaupt nicht zurecht komme. Und das die Integer überlaufen ist ja das Problem.

    Wenn niemand dafür eine Lösung hat, lasse ich eben diesen Fortschrittsbalken einfach weg.

    naja
    danke für die Antworten^^

    0
  • ?

    das programm würde länger laufen als du lebst. ist dir das klar?

    0
  • P

    Aber wenn in ferner Zukunft schließlich die Sonne erlischt, zeigt der Fortschrittsbalken so um die 10% an, und darum gehts hier ja schließlich. 🙂

    0
  • E

    es ging um BackTracking, und da braucht das nicht ganz so lang^^

    ne, danke für die Antworten, ich hab den Balken einfach weggelassen, da wars sogar schneller 😃

    0
  • ?

    pock schrieb:

    Aber wenn in ferner Zukunft schließlich die Sonne erlischt, zeigt der Fortschrittsbalken so um die 10% an, und darum gehts hier ja schließlich. 🙂

    "Vielen Dank, daß Sie 'Intelligentes Leben' gespielt haben. Noch eine Runde?"

    0
  • W

    HumeSikkins schrieb:

    selbst wenn dein Prozess nur aus dem Inkrementieren eines Riesen-Integers besteht, wirst du in deiner Lebensspanne 2^2000 nicht erreichen.

    100 schrieb:

    das programm würde länger laufen als du lebst. ist dir das klar?

    von solchen Detail-Problemen sollte man sich als echter Hacker nicht aus der Ruhe bringen lassen 🕶

    Hier ist mein Vorschlag:

    #include <iostream>
#include <string>
#include <iterator>
#include <vector>
#include <limits>
#include <iomanip>
#include <sstream>
#include <algorithm>
#include <cassert>

class HyperCounter
{
public:
    explicit HyperCounter( double mant = 0.0, int exp10 = 0 ) // zahl = mant(isse) 10^exp10
        : m_digits( 1, '0' )
    {
        if( mant == 0.0 )
            return;
        assert( mant > 0.0 );
        // --   normalisieren
        while( mant >= 1.0 )
        {
            mant /= 10.0;
            ++exp10;
        }
        while( mant < 0.1 )
        {
            mant *= 10.0;
            --exp10;
        }
        assert( exp10 > 0 );

        using namespace std;
        ostringstream buf;
        buf << setprecision( min( exp10, std::numeric_limits< double >::digits10 ) ) << mant;
        const string zahl = buf.str();
        vector< char > digits( exp10, '0' );
        copy( zahl.begin() + zahl.find( '.' ) + 1, zahl.end(), digits.rbegin() );
        swap( digits, m_digits );
    }

    HyperCounter& operator++()
    {
        for( std::vector< char >::iterator i = m_digits.begin(); i!= m_digits.end(); ++i )
        {
            if( ++*i <= char('9') )
                return *this;
            *i = '0';
        }
        m_digits.push_back('1');
        return *this;
    }

    bool operator==( const HyperCounter& b ) const
    {
        return m_digits == b.m_digits;
    }
    bool operator!=( const HyperCounter& b ) const { return !(*this == b); }

    friend std::ostream& operator<<( std::ostream& out, const HyperCounter& hc )
    {
        std::copy( hc.m_digits.rbegin(), hc.m_digits.rend(), std::ostream_iterator< char >( out ) );
        return out;
    }
private:
    std::vector< char > m_digits;
};

int main()
{
    // 2^2000 ca.= 1,1481306952742545242328332011777 E+602
    const HyperCounter upper_limit( 1.1481306952742545242328332011777, 602 ); 

    HyperCounter hc;
    for( int cnt = 1; hc != upper_limit; ++hc, ++cnt )
        if( cnt % 924271 == 0 )   // cnt dient nur der beschleunigten Ausgabe
        {
            std::cout << hc << '\r';
            cnt = 0;
        }
    return 0;
}

    Im Release-Mode übersetzt lässt es schon nach weniger als 10Sek MAX_INT hinter sich.

    Gruß
    Werner

    0
  • E

    danke danke^^

    aber ich hoffe, dass das jetzt nicht für mich geschrieben war :D, denn wie gesagt ich hab einfach den Balken weggelassen.....

    @ Gott (ich meine den unregistrierten User, nicht den Herrn, der da irgendwo oben sitzt 😉 )

    wenn du mich fragst: wir kommen nicht bei den 10 Mrd. Jahren an: irgendwann in 10-20 Jahren, kommt ein großes fettes "GAME OVER" auf dem Monitor^^
    oder unser Server, von nicht PC-irren gerne auch mal schlampig als "Erde" bezeichnet, stürzt mit einem Bluescreen ab.

    0
Anmelden zum Antworten