3. Integer Overflow vorbeugen

Integer Overflow vorbeugen

  • J

    Servus,

    ich habe eine Funktion, in der die Werte schon nach oben gehen können. Mit meiner Erfahrung in Java dachte ich an den Typen 'BigInt' statt int. Wie würdet ihr das in C++ machen und mit welchen Werten würdet ihr testen, ob das auch klappt? Danke vorab.

    /**
     * Methode berechnet die Konserviertheit eines Strings. 
     * Dabei werden zuerst das Auftreten eines Symbols im String summiert. Dann 
     * wird das relative Auftreten ermittelt. Dann wird dieser Wert etwa 0.3 quadriert.
     * Durch das Quadrieren wirken sich konservierte Symbole besonders intensiv auf den 
     * Score aus. Für einen String werden alle Symbolscores summiert.
     * 
     * @param colStringToScore
     * @return 
     */
    double computeConservationScoreOfString( seqan::CharString colStringToScore ){

        double score = 0.0;
        int numberOfSymbols = seqan::length( colStringToScore );
        string curAlphabetSymbolString;
        string curCharString;
        int matches = 0;

        for ( int i = 0; i < global::g_aminoAlphabet.size(); i++ ){ // gehe das Alphabet ab

            curAlphabetSymbolString = global::g_aminoAlphabet.at( i );
            matches = 0;

            // Lauf den String für dieses Symbol ab
            for ( int j = 0; j < numberOfSymbols; j++ ){
                curCharString = "";

                char curChar = colStringToScore[j];
                curCharString = curChar;

                if ( curAlphabetSymbolString == curCharString )
                {
                    matches++;
                }
                else {}
            } // Ende für dieses Symbol, Matches sind ermittelt

            double squareMatches = matches * matches; // Quadrieren der matches
            double symbolRelativeScore = squareMatches / (numberOfSymbols * numberOfSymbols);
            score = score + symbolRelativeScore;
        } // Ende für alle Symbole

        return score;
    }
    0
  • E

    Wo ist diese kritische Grösse und was ist seqan ? Und wieso hast du einen leeren else -Block?

    0
  • C

    Nur mal zur Abschätzung: Mit welchen Datenmengen rechnest du, daß du dir Gedanken über Overflows machst? Um einen normalgroßen int aus dem Gleichgewicht zu bringen, mußt du schon mehr als 46000 gleiche Zeichen in der Eingabe haben.

    (Ansonsten gibt es auch schnellere Möglichkeiten zu zählen)

    0
  • J

    Es geht darum, dass ich eine Zahl quadriere, das ist die kritische Größe in Zeile 39. Ich würde gerne wissen wie groß die Zahl werden darf, dass diese mir beim Quadrieren keinen Overflow verursacht? Da würde ich dann vorher eine if-Abfrage einbauen, ob der Wert kleiner als der Grenzwert ist, der gerade noch quadriert werden kann.

    seqan::length() liefert mir einfach die Länge eines Strings, der ist einige Male bei meinen Testdaten schon 2000 Zeichen lang. Da das Programm auch andere dann nutzen, kann ich schwer einschätzen, ob da einer einen String mit wasweissichwieviel Zeichen reinschickt.

    0
  • E
     

    if(matches > std::sqrt(numeric_limits<int>::max())
{
  //zu gross
}

    Aber das ist keine schöne Lösung. mathes sollte unsigned sein. Und wieso nutzt du nicht die STD?

    0
Anmelden zum Antworten