Perl Bug bei int? (Allgemeines zu Perl) - Perl-Community.de

Start · Board · Anwendungen/Programme/Skripte in Perl · Allgemeines zu Perl

2024-04-26 09:43:05
Europe/Berlin
Einloggen (Registrieren)
- Einstellungen
- Statistics
Jemand zu Hause?
0 Benutzer online

[thread]18175[/thread]

submit to reddit

Perl Bug bei int?

Tags: perl5 Ähnliche Threads

Leser: 35

Articles: hide open all | hide show old branches

+46 replies
Rolf_PlusW

2013-03-01 11:29

User since
2006-12-13
22 Artikel
BenutzerIn

warum gibt
perl -E say ' int(19.9*100)'
1989
aus, und
perl -E say ' 19.9*100 '
1990
? Mit andern Zahlen ist das Ergebnis korrekt, nur die 19.9 macht Probleme.
- +2 replies
- Rolf_PlusW
  
  2013-03-01 11:36
  
  User since
  2006-12-13
  22 Artikel
  BenutzerIn
  
  gleicher Fehler bei
  
  $perl -E 'printf "%.0f\n", 19.9*100'
  1990
  $ perl -E 'printf "%d\n", 19.9*100'
  1989
  - Rolf_PlusW
    
    2013-03-01 11:42
    
    User since
    2006-12-13
    22 Artikel
    BenutzerIn
    
    ok, dia Antwort liegt wohl darin :
    
    Don't blame Perl. It's the same as in C. IEEE says we have to do this. Perl numbers whose absolute values are integers under 2**31 (on 32-bit machines) will work pretty much like mathematical integers. Other numbers are not guaranteed.
    (aus perfaq)
- GwenDragon
  
  2013-03-01 11:41
  
  User since
  2005-01-17
  14533 Artikel
  Admin1
  
  Wenn du int auf Arithmetik mit floats anwendest gibt es Rundungsfehler.
  Auf http://perldoc.perl.org/functions/int.html ist es erklärt.
  die Drachin, Gwendolyn
  
  Unterschiedliche Perl-Versionen auf Windows (fast wie perlbrew) • Meine Perl-Artikel
- +27 replies
- bianca
  
  2013-03-01 16:37
  User since
  2009-09-13
  6977 Artikel
  BenutzerIn
  Siehe auch Richtig INTen
  
  Meine aktuelle Lösung sieht so aus:
  
  Code (perl): (dl )
  
  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
  
  sub integer { my $wert = shift ( @_ ) || 0; if ($wert =~ /e\-\d+$/) { return 0; } if ($wert =~ /\./) { my $neu = ''; for (my $st = 0; $st < length($wert); $st ++) { if (substr($wert,$st,1) eq '.') { last; } else { $neu .= substr($wert,$st,1); } } $neu = 0 if $neu eq ''; $wert = $neu; $wert = 0 if $wert == -0; } return $wert; }
  
  10 print "Hallo"
  20 goto 10
  - +26 replies
  - GUIfreund
    
    2013-03-01 18:15
    
    User since
    2011-08-08
    559 Artikel
    BenutzerIn
    
    2013-03-01T15:37:18 bianca
    Siehe auch Richtig INTen
    
    Meine aktuelle Lösung sieht so aus:
    
    @bianca:
    Versuch's doch mal mit sprintf '%.0f'. Das dürfte das liefern, was du brauchst.
    
    int schneidet gnadenlos ab (Rundung Richtung Null).
    sprintf '%.0f' rundet zur nächsten Integer.
    floor (in POSIX) rundet zur nächstkleineren Integer (nach links).
    ceil (in POSIX) rundet zur nächstgrößeren Integer (nach rechts).
    Gruß
    GUIfreund
    - +14 replies
    - bianca
      
      2013-03-01 19:33
      
      User since
      2009-09-13
      6977 Artikel
      BenutzerIn
      
      2013-03-01T17:15:29 GUIfreund
      int schneidet gnadenlos ab (Rundung Richtung Null).
      
      Nein. Es geht nur entweder oder aber nicht beides.
      
      2013-03-01T17:15:29 GUIfreund
      sprintf '%.0f' rundet zur nächsten Integer.
      
      Dann ist es kein int() !
      
      2013-03-01T17:15:29 GUIfreund
      @bianca:
      Versuch's doch mal mit sprintf '%.0f'. Das dürfte das liefern, was du brauchst.
      
      Das verstehe ich jetzt nicht. Hatten wir nicht damals schon festgestellt, dass dein sprintf() nicht ausreicht? Du warst doch beteiligt damals, oder nicht?
      
      Code (perl): (dl )
      
      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
      
      #!/usr/bin/perl use strict; use warnings; my $space = '.' x 25; my ($int,$erwartet); foreach my $test ( -19854.94 - -3970.99 - -15883.95,'=0', .57 * 100,'=57', .58,'=0', 12.345,'=12', 57.00000000000000001,'=57', 0.000000000000001,'=0', 1.01205,'=1', -0.903,'=0', -1.9999999 + .000000099999999,'=-1' ) { if (substr ($test,0,1) eq '=') { $erwartet = substr($test,1); print "Erwartet '$erwartet'\n\n"; } else { $int = GUIfreund($test); print "\'$test\'".substr($space,0,25 - length ($test))."geINTet mit GUIfreund: \'$int\'".substr($space,0,25 - length ($int))."\n"; $int = integer($test); print "\'$test\'".substr($space,0,25 - length ($test))."geINTet mit Bianca : \'$int\'".substr($space,0,25 - length ($int))."\n"; } } ############################################################################### sub GUIfreund { sprintf('%.0f',$_[0]); } sub integer { my $wert = shift ( @_ ) || 0; if ($wert =~ /e\-\d+$/) { return 0; } if ($wert =~ /\./) { my $neu = ''; for (my $st = 0; $st < length($wert); $st ++) { if (substr($wert,$st,1) eq '.') { last; } else { $neu .= substr($wert,$st,1); } } $neu = 0 if $neu eq ''; $wert = $neu; $wert = 0 if $wert == -0; } return $wert; }
      
      Quote
      '1.81898940354586e-012'....geINTet mit GUIfreund: '0'........................
      '1.81898940354586e-012'....geINTet mit Bianca : '0'........................
      Erwartet '0'
      
      '57'.......................geINTet mit GUIfreund: '57'.......................
      '57'.......................geINTet mit Bianca : '57'.......................
      Erwartet '57'
      
      '0.58'.....................geINTet mit GUIfreund: '1'........................
      '0.58'.....................geINTet mit Bianca : '0'........................
      Erwartet '0'
      
      '12.345'...................geINTet mit GUIfreund: '12'.......................
      '12.345'...................geINTet mit Bianca : '12'.......................
      Erwartet '12'
      
      '57'.......................geINTet mit GUIfreund: '57'.......................
      '57'.......................geINTet mit Bianca : '57'.......................
      Erwartet '57'
      
      '1e-015'...................geINTet mit GUIfreund: '0'........................
      '1e-015'...................geINTet mit Bianca : '0'........................
      Erwartet '0'
      
      '1.01205'..................geINTet mit GUIfreund: '1'........................
      '1.01205'..................geINTet mit Bianca : '1'........................
      Erwartet '1'
      
      '-0.903'...................geINTet mit GUIfreund: '-1'.......................
      '-0.903'...................geINTet mit Bianca : '0'........................
      Erwartet '0'
      
      '-1.9999998'...............geINTet mit GUIfreund: '-2'.......................
      '-1.9999998'...............geINTet mit Bianca : '-1'.......................
      Erwartet '-1'
      
      sprintf() macht hier drei Fehler, soweit ich das sehe.
      
      Aber vielleicht hast du auch eine andere Auffassung davon, was int bedeutet. Für mich bedeutet es das fehlerfreie Abschneiden der Nachkommastellen ohne irgendwelche Rundungen. Denn wenn ich Rundungen haben will habe ich kein int() :)
      Aber zum Runden ist sprintf() noch viel mehr ungeeignet als zum int'en.
      Last edited: 2013-03-01 19:37:40 +0100 (CET)
      10 print "Hallo"
      20 goto 10
      - GUIfreund
        
        2013-03-02 15:55
        
        User since
        2011-08-08
        559 Artikel
        BenutzerIn
        
        2013-03-01T18:33:33 bianca
        Das verstehe ich jetzt nicht. Hatten wir nicht damals schon festgestellt, dass dein sprintf() nicht ausreicht? Du warst doch beteiligt damals, oder nicht?
        
        Stimmt, das hattest du schon in deinem damaligen Thread bewiesen. Ich hätte mich daran erinnern oder den Thread noch mal ansehen müssen.
        Gruß
        GUIfreund
      - +12 replies
      - GUIfreund
        
        2013-03-04 19:16
        
        User since
        2011-08-08
        559 Artikel
        BenutzerIn
        
        Fehler in biancas Testskript?
        
        An bianca: Auf die Gefahr hin, dass du mich jetzt totschlägst - hier ist schon wieder eine GUIfreund-sub. Diesmal allerdings mit dem feinen Unterschied, dass sie auch als Abschneide-Routine gedacht ist.
        
        Code (perl): (dl )
        
        1 2 3 4
        
        sub GUIfreund { use POSIX qw(floor ceil); return $_[0] > 0 ? floor($_[0]) : ceil($_[0]); }
        
        Dein Testskript zeigt nur 1 Abweichung zu deiner Abschneide-Routine, und das ausgerechnet bei einem völlig harmlosen Eingabewert:
        
        Code: (dl )
        
        1 2 3
        
        '57'.......................geINTet mit GUIfreund: '56'..... '57'.......................geINTet mit Bianca : '57'..... Erwartet '57'
        
        Wie das Schicksal so spielt, ein paar Zeilen später dann das:
        
        Code: (dl )
        
        1 2 3
        
        '57'.......................geINTet mit GUIfreund: '57'..... '57'.......................geINTet mit Bianca : '57'..... Erwartet '57'
        
        Selbe Eingabe, verschiedenes Ergebnis?? Das veranlasste mich, mir dein Skript genauer anzusehen. Dann habe ich die prints etwas geändert, um den Testwert in der möglichst vollen Genauigkeit zu sehen.
        
        Code (perl): (dl )
        
        1 2 3 4
        
        print "geINTet mit GUIfreund: \'$int\'".substr($space,0,15 - length ($int)); printf "Eingabe %.15f\n", $test; print "geINTet mit Bianca : \'$int\'".substr($space,0,15 - length ($int)); printf "Eingabe %.15f\n", $test;
        
        Und siehe da, an der entscheidenden Stelle war der Testwert etwas kleiner:
        
        Code: (dl )
        
        1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
        
        geINTet mit GUIfreund: '0'..............Eingabe 0.000000000001819 geINTet mit Bianca : '0'..............Eingabe 0.000000000001819 Erwartet '0' geINTet mit GUIfreund: '56'.............Eingabe 56.999999999999993 geINTet mit Bianca : '57'.............Eingabe 56.999999999999993 Erwartet '57' geINTet mit GUIfreund: '0'..............Eingabe 0.580000000000000 geINTet mit Bianca : '0'..............Eingabe 0.580000000000000 Erwartet '0' geINTet mit GUIfreund: '12'.............Eingabe 12.345000000000001 geINTet mit Bianca : '12'.............Eingabe 12.345000000000001 Erwartet '12' geINTet mit GUIfreund: '57'.............Eingabe 57.000000000000000 geINTet mit Bianca : '57'.............Eingabe 57.000000000000000 Erwartet '57' geINTet mit GUIfreund: '0'..............Eingabe 0.000000000000001 geINTet mit Bianca : '0'..............Eingabe 0.000000000000001 Erwartet '0' geINTet mit GUIfreund: '1'..............Eingabe 1.012050000000000 geINTet mit Bianca : '1'..............Eingabe 1.012050000000000 Erwartet '1' geINTet mit GUIfreund: '0'..............Eingabe -0.903000000000000 geINTet mit Bianca : '0'..............Eingabe -0.903000000000000 Erwartet '0' geINTet mit GUIfreund: '-1'.............Eingabe -1.999999800000001 geINTet mit Bianca : '-1'.............Eingabe -1.999999800000001 Erwartet '-1'
        
        Gruß
        GUIfreund
        
        +10 replies
        
        bianca
        
        2013-03-05 06:56
        
        User since
        2009-09-13
        6977 Artikel
        BenutzerIn
        
        2013-03-04T18:16:03 GUIfreund
        Dann habe ich die prints etwas geändert, um den Testwert in der möglichst vollen Genauigkeit zu sehen.
        
        Und das tust du wiederum mit printf() von dem wir doch wissen, dass es in diesem Bereich nicht wie benötigt arbeitet.
        Was soll mir das jetzt sagen?
        10 print "Hallo"
        20 goto 10
        
        +9 replies
        
        GUIfreund
        
        2013-03-05 12:44
        
        User since
        2011-08-08
        559 Artikel
        BenutzerIn
        
        2013-03-05T05:56:50 bianca
        2013-03-04T18:16:03 GUIfreund
        Dann habe ich die prints etwas geändert, um den Testwert in der möglichst vollen Genauigkeit zu sehen.
        
        Und das tust du wiederum mit printf() von dem wir doch wissen, dass es in diesem Bereich nicht wie benötigt arbeitet.
        
        Ich verwende printf() nicht zum Arbeiten - also zum Abschneiden, sondern zum Anzeigen des Eingabewertes bei der Gegenüberstellung der Ergebnisse verschiedener Verfahren zum Abschneiden. Und ich benutze dabei printf() nicht zum Runden des Eingabewertes, sondern im Gegenteil dazu, diesen in der Anzeige möglichst wenig zu runden. Du hingegen zeigst in den Prints einen deutlich gerundeten Eingabewert, was es schwer macht, Unterschiede in den Ergebnissen zu verstehen.
        
        Zur Sache selbst:
        
        Ich finde es bemerkenswert, dass deine int-Routine bei deinen Testdaten auch in Grenzfällen das korrekte Ergebnis liefert. Wirklich eine tolle Leistung.
        
        Ich finde es bemerkenswert, dass ceil() nicht denselben Fehler wie int() hat. Da beide für negative Zahlen dasselbe Ergebnis haben sollen, nahm ich an, dass sie auch denselben Kode verwenden.
        
        Mit Muffis Vorschlag könnte man das Ergebnis der neuen GUIfreund-sub noch etwas verbessern, sodass alle deine Testfälle das richtige Ergebnis liefern. Und durch Verkleinern von Epsilon könnte man die Trefferquote noch steigern. Aber 100% kann man nie erreichen. Mit Epsilon = e-15 ist man schon hart am Grundrauschen der Gleitkommaarithmetik.
        Gruß
        GUIfreund
        
        +8 replies
        
        Muffi
        
        2013-03-05 13:09
        
        User since
        2012-07-18
        1465 Artikel
        BenutzerIn
        
        Eine 100%-Lösung kanns nicht geben. Es ist situationsabhängig welches eps das passendste ist.
        Es kommt darauf an welche Genauigkeit deine Werte haben.
        
        Es gibt auch kein Grundrauschen der Gleitkommaarithmetik. Es gibt Rechenoperationen und Operanden und abhängig von diesen verringert sich mit jeder Operation deine Genauigkeit bzw. deine Anzahl gültiger Bits.
        
        Anhand der Berechnungen, die du durchführen willst kannst du deine gültigen Stellen abschätzen und anhand derer dann dein eps wählen.
        
        Ein ganz simples Beispiel, das ziemlich viele Bits "klaut"
        
        Code (perl): (dl )
        
        ((1 - 0.9999) * 10000)
        
        Das sollte 1 ergeben.
        
        [EDIT]
        Aus Faustformel (wenn ichs noch richtig in Erinnerung hab) an verlorenen Bits/Stellen
        Addition: 0-1 Bit
        Multiplikation: 0-1 Bit
        Division: 0-1 Bit
        Subtraktion: Bei fast gleich großen Zahlen verringern sich die gültigen Stellen um die Anzahl der ersten Stellen, in denen die beiden Zahlen übereinstimmen. <= Da kanns gefährlich werden
        Last edited: 2013-03-05 13:32:14 +0100 (CET)
        1 + 1 = 10
        
        +5 replies
        
        bianca
        
        2013-03-05 15:08
        
        User since
        2009-09-13
        6977 Artikel
        BenutzerIn
        
        2013-03-05T12:09:12 Muffi
        Ein ganz simples Beispiel, das ziemlich viele Bits "klaut"
        
        Code (perl): (dl )
        
        ((1 - 0.9999) * 10000)
        
        Das sollte 1 ergeben.
        
        Verflixt, das gibt nur mit sprintf korrekt 1. Aber eine Genauigkeit für 4 Stellen hinter dem Komma hätte ich schon gern.
        Wie bekomme ich das ohne sprintf abgefangen?
        Am liebsten mit dem Code von Gast Wer, den nutze ich derzeit, weil er keine Schleife drin hat.
        10 print "Hallo"
        20 goto 10
        
        +4 replies
        
        Raubtier
        
        2013-03-05 15:45
        
        User since
        2012-05-04
        1054 Artikel
        BenutzerIn
        
        Sorry, was meinst du mit das mit "das gibt nur mit sprintf korrekt 1"?
        
        Code: (dl )
        
        1 2 3 4
        
        $ perl -E'say sprintf("%.13f",((1 - 0.9999) * 10000))' 0.9999999999999 $ perl -E'say sprintf("%.12f",((1 - 0.9999) * 10000))' 1.000000000000
        
        Du hast hier also immer noch 12 Dezimalstellen Genauigkeit, nicht 4.
        
        Mein Standpunkt ist einfach:
        * Bei doubles nie direkt mit == vergleichen, sondern immer differenz < epsilon abfragen
        * Wenn man was genaueres will, dann muss man eben eine Bibliothek nehmen, die exakt rechnet.
        
        Außerdem wichtig zu wissen: es gibt auch Komma-Zahlen, die exakt dargestellt werden können. Zum Beispiel:
        
        Code: (dl )
        
        1 2 3 4
        
        $ perl -E'say sprintf("%.18f",0.125)' 0.125000000000000000 $ perl -E'say sprintf("%.18f",0.25)' 0.250000000000000000
        
        Andere dagegen nicht:
        
        Code: (dl )
        
        1 2
        
        $ perl -E'say sprintf("%.18f",0.3)' 0.299999999999999989
        
        +3 replies
        
        bianca
        
        2013-03-05 17:43
        
        User since
        2009-09-13
        6977 Artikel
        BenutzerIn
        
        2013-03-05T14:45:57 Raubtier
        Sorry, was meinst du mit das mit "das gibt nur mit sprintf korrekt 1"?
        
        Damit meine ich, dass das Script aus msg #166120 mit diesem Beispiel nur mit der Lösung von GUIFreund korrekt 1 ausgibt. Was mir eigentlich ein wenig stinkt. Denn in allen anderen Fällen war die sprintf Lösung entweder gleich oder schlechter, was es leichter machte, sie nieder zu machen :) Dies ist das erste Beispiel wo sie "richtiger" ist als alle anderen.
        
        2013-03-05T14:45:57 Raubtier
        Wenn man was genaueres will, dann muss man eben eine Bibliothek nehmen, die exakt rechnet.
        
        Brauche ich. Was empfiehlst du?
        10 print "Hallo"
        20 goto 10
        
        GUIfreund
        
        2013-03-05 19:23
        
        User since
        2011-08-08
        559 Artikel
        BenutzerIn
        
        2013-03-05T16:43:29 bianca
        2013-03-05T14:45:57 Raubtier
        Wenn man was genaueres will, dann muss man eben eine Bibliothek nehmen, die exakt rechnet.
        
        Brauche ich. Was empfiehlst du?
        
        Ich vermute, dass du dabei bist, ein kaufmännisches Programm zu schreiben. Da gibt es bestimmt exakte Rundungsvorschriften. Schließlich wird beim Rechnen mit Bleistift und Papier auch gerundet. Und die alten Rechenmaschinen arbeiteten ebenfalls dezimal. Wenn du solche Vorschriften in Perl einhalten kannst, kannst du bei Gleitkomma bleiben. Sonst bräuchtest du ein Paket für Dezimalarithmetik. So was gibt es bestimmt (vielleicht nicht gerade in Perl), könnte aber etwas kosten.
        
        Letzer Ausweg: zurück zu Cobol. Meines Wissens haben die dezimal gerechnet.
        Gruß
        GUIfreund
        
        GwenDragon
        
        2013-03-05 19:36
        
        User since
        2005-01-17
        14533 Artikel
        Admin1
        
        Wenn du Währungen umrechnen musst, dann sollte folgendes klappen:
        immer Cent-Beträge verwenden und Math::BigInt //EDIT oder bigint (bitte vorher über Bugs informieren) für große Integer verwenden.
        
        Oder gleich andere Sprache als Backend, die kaufmännisch genau rechnen kann.
        Last edited: 2013-03-05 19:43:01 +0100 (CET)
        die Drachin, Gwendolyn
        
        Unterschiedliche Perl-Versionen auf Windows (fast wie perlbrew) • Meine Perl-Artikel
        
        +2 replies
        
        GUIfreund
        
        2013-03-05 19:09
        
        User since
        2011-08-08
        559 Artikel
        BenutzerIn
        
        2013-03-05T12:09:12 Muffi
        Es gibt auch kein Grundrauschen der Gleitkommaarithmetik.
        
        Damit hatte ich die unvermeidlichen Rundungsfehler beim Umwandeln zwischen Dezimal und Binär gemeint. Du gibst deine Zahlen als Dezimalzahlen ein und lässt die Ergebnisse als solche ausgeben. Intern wird mit Gleitkommazahlen, also Binärzahlen, gearbeitet. Raubtier zeigt in msg #166228 zwei Beispiele, wo verlustfrei umgewandelt wird. Es klappt z. B. auch mit 17.625 = 17 + 1/2 + 1/8.
        
        2013-03-05T12:09:12 Muffi
        Subtraktion: Bei fast gleich großen Zahlen ..... Da kanns gefährlich werden
        
        Bei Addition gilt sinngemäß dasselbe (bei entgegengesetzten Vorzeichen).
        Außerdem noch die Mult. mit sehr großen und die Div. durch absolut sehr kleine Zahlen: da werden die Rundungsfehler mit skaliert.
        
        Mein Fazit: Man kann bei Gleitkomma den Rundungsfehlern nicht entkommen. Deshalb bewundere ich biancas int-Routine um so mehr. Ich war freilich überzeugt, dass auch diese nicht perfekt ist. Vielen Dank an Muffi für das Beispiel.
        Gruß
        GUIfreund
        
        bianca
        
        2013-03-05 19:55
        
        User since
        2009-09-13
        6977 Artikel
        BenutzerIn
        
        2013-03-05T18:09:35 GUIfreund
        Deshalb bewundere ich biancas int-Routine um so mehr.
        
        Danke :))
        
        2013-03-05T18:09:35 GUIfreund
        Ich war freilich überzeugt, dass auch diese nicht perfekt ist. Vielen Dank an Muffi für das Beispiel.
        
        Ja, und schon wieder bin ich danieder....
        
        Aber in meinen eigenen Projekten bin ich schon überwiegend auf die Ganzzahlen umgestiegen. Von daher habe ich die brenzligen Stellen immer nur beim "erzeugen" der Ganzzahlen, da muss ich nämlich einmal nach der Multiplikation mit 100 int'en. Denn man sieht ja, dass selbst das der PC bzw. Perl nicht mathematisch korrekt hinbekommt.
        10 print "Hallo"
        20 goto 10
        
        Muffi
        
        2013-03-05 08:37
        
        User since
        2012-07-18
        1465 Artikel
        BenutzerIn
        
        Dir fehlt das epsilon. Du musst per Hand angeben, was du noch als 57 ansehen willst, das kann Perl nicht wissen.
        
        z.B.
        
        Code (perl): (dl )
        
        1 2
        
        my $epsilon = 5e-13; # das was du als Toleranz ansiehst return floor($_[0] + $epsilon);
        
        1 + 1 = 10
    - +11 replies
    - GwenDragon
      
      2013-03-01 19:44
      
      User since
      2005-01-17
      14533 Artikel
      Admin1
      
      (s)printf ist KEINE Integer- und auch keine Rundungsfunktion!
      Es formatiert nur Zahlen nach einem bestimmten Ausgabeformat!
      
      Nicht so sonderlich sinnvoll printf als Methode zur Erzwingung einer Ganzzahl anzupreisen. Schlecht für Anfänger, wenn die sowas falsch lernen.
      
      Nicht nur die Ariane 5 stürzte wegen so einem Unsinn ab. Auch Patriots und anderes waren Opfer von falscher Berechnung.
      Last edited: 2013-03-01 19:45:39 +0100 (CET)
      die Drachin, Gwendolyn
      
      Unterschiedliche Perl-Versionen auf Windows (fast wie perlbrew) • Meine Perl-Artikel
      - bianca
        
        2013-03-01 19:48
        
        User since
        2009-09-13
        6977 Artikel
        BenutzerIn
        
        2013-03-01T18:44:17 GwenDragon
        (s)printf ist KEINE Integer- und auch keine Rundungsfunktion![...]Schlecht für Anfänger, wenn die sowas falsch lernen.
        
        Danke für deine Unterstützung. Ich denke manchmal, ich sehe nicht richtig. 2009 erst ganz frisch erörtert, 2012 aufgewärmt und jetzt kommt der schon wieder mit seinem sprintf()........
        
        Editiert von bianca: Unsachliches entschärft
        Last edited: 2013-03-01 19:55:25 +0100 (CET)
        10 print "Hallo"
        20 goto 10
      - +9 replies
      - GUIfreund
        
        2013-03-02 14:31
        
        User since
        2011-08-08
        559 Artikel
        BenutzerIn
        
        2013-03-01T18:44:17 GwenDragon
        (s)printf ist KEINE Integer- und auch keine Rundungsfunktion!
        Es formatiert nur Zahlen nach einem bestimmten Ausgabeformat!
        
        Die Formatierung einer Gleitkommazahl bedeutet Umwandlung in Dezimalschreibweise. Dabei ist eine Rundung meist unvermeidlich.
        
        2013-03-01T18:44:17 GwenDragon
        Nicht so sonderlich sinnvoll printf als Methode zur Erzwingung einer Ganzzahl anzupreisen. Schlecht für Anfänger, wenn die sowas falsch lernen.
        
        Nicht nur die Ariane 5 stürzte wegen so einem Unsinn ab. Auch Patriots und anderes waren Opfer von falscher Berechnung.
        
        Hast du ein Beispiel dafür, dass sprintf ein falsches Ergebnis liefert? Ok, das Ergebnis ist ein String, keine reine Zahl. In den Fällen, wo du eine reine Zahl benötigst, kannst du das erzwingen, z. B. mit
        
        Code (perl): (dl )
        
        $ganz = sprintf ('%.0f', $wert) + 0;
        
        Ein Stück Kode, das stets ein richtiges Ergebnis liefert, kann IMHO kaum Quelle von falscher Berechnung sein. Es kann immer noch falsch angewendet werden, aber das ist eine andere Geschichte.
        Gruß
        GUIfreund
        
        +8 replies
        
        GwenDragon
        
        2013-03-02 14:43
        
        User since
        2005-01-17
        14533 Artikel
        Admin1
        
        C:\>perl -e"print 19.946*100" 1994.6
        Soweit noch ok.
        
        C:\>perl -e"printf ('%.0f', 19.946*100) + 0;" 1995
        Oh. Aufgerundet!
        
        Na? Das ist eben kein Int-Ersatz. Integer soll abschneiden, nicht runden.
        
        printf ist eben KEIN Ersatz, sondern klappt nur unter bestimmten Umständen.
        
        //EDIT2:
        C:\>perl -MPOSIX -e"print floor(19.946*100);" 1994
        Yippie! Aber logisch, denn floor soll das so machen. ;)
        Funktioniert soaber eben nur bei positiven Zahlen.
        Ist eben auch kein Int-Ersatz.
        
        Manche Funktionen lassen sich missbrauchen, aber nur wenn diejeniogen wissen wies intern geht.
        Nachfolgende Programmierende nach dir werden Schreikrämpfe kriegen, wenn sie die Fallen nicht in-und-auswendig kennen.
        Ich will keien Programme sehen, in denen so ein "Int" meist funktioniert. Irgwendwann kommt der böse Tag des Fails.
        Last edited: 2013-03-02 14:57:48 +0100 (CET)
        die Drachin, Gwendolyn
        
        Unterschiedliche Perl-Versionen auf Windows (fast wie perlbrew) • Meine Perl-Artikel
        
        +7 replies
        
        GUIfreund
        
        2013-03-02 16:25
        
        User since
        2011-08-08
        559 Artikel
        BenutzerIn
        
        Du sprichst hier vom Abschneiden, während ich in meinem vorigen Beitrag, auf den du antwortest, von Runden sprach. Und auch in meinem ersten Beitrag in diesem Thread msg #166117 schrieb ich
        Quote
        int schneidet gnadenlos ab (Rundung Richtung Null).
        sprintf '%.0f' rundet zur nächsten Integer.
        floor (in POSIX) rundet zur nächstkleineren Integer (nach links).
        ceil (in POSIX) rundet zur nächstgrößeren Integer (nach rechts).
        
        Es würde mir nicht im Traum einfallen, sprintf '%.0f' zum Abschneiden zu verwenden. Eher kann man umgekehrt (etwas unvollkommen) int zum Runden zur nächsten Integer verwenden.
        Gruß
        GUIfreund
        
        +6 replies
        
        GwenDragon
        
        2013-03-02 18:39
        
        User since
        2005-01-17
        14533 Artikel
        Admin1
        
        Oh, wir diskutieren jetzt außerhalb des Themas des Threaderstellers.
        Geht also gar nicht mehr um Int.
        
        Na, denn. Auch ok.
        die Drachin, Gwendolyn
        
        Unterschiedliche Perl-Versionen auf Windows (fast wie perlbrew) • Meine Perl-Artikel
        
        +3 replies
        
        GUIfreund
        
        2013-03-02 19:02
        
        User since
        2011-08-08
        559 Artikel
        BenutzerIn
        
        War meine Schuld. Ich hatte bianca falsch verstanden, dachte, ihr ginge es um's Runden. Hat sich dann aufgeschaukelt.
        Gruß
        GUIfreund
        
        +2 replies
        
        bianca
        
        2013-03-02 19:13
        
        User since
        2009-09-13
        6977 Artikel
        BenutzerIn
        
        2013-03-02T18:02:16 GUIfreund
        Ich hatte bianca falsch verstanden
        
        Was war mißverständlich an meinen Texten?
        Nur damit ich mich nächstens besser ausdrücke.
        10 print "Hallo"
        20 goto 10
        
        GUIfreund
        
        2013-03-03 18:40
        
        User since
        2011-08-08
        559 Artikel
        BenutzerIn
        
        An dem Missverständnis war ich selbst schuld. Du hattest am Anfang deines Beitrags einen Link zu deinem früheren ~~Link~~Thread geschrieben. Ich hätte nur draufklicken brauchen.
        Last edited: 2013-03-04 18:01:36 +0100 (CET)
        Gruß
        GUIfreund
        
        +2 replies
        
        jan
        
        2013-03-02 19:20
        
        User since
        2003-08-04
        2536 Artikel
        ModeratorIn
        
        2013-03-02T17:39:58 GwenDragon
        Oh, wir diskutieren jetzt außerhalb des Themas des Threaderstellers.
        
        Naja, Du schriebst:
        
        Quote
        (s)printf ist KEINE Integer- und auch keine Rundungsfunktion!
        Es formatiert nur Zahlen nach einem bestimmten Ausgabeformat!
        
        Inwiefern rundet (s)printf denn nicht?
        
        GwenDragon
        
        2013-03-03 11:10
        
        User since
        2005-01-17
        14533 Artikel
        Admin1
        
        Ich meinte damit: sprintf ist eine Funktion zur Ausgabe von formatierten Daten als Zeichenkette, nicht eine mathematische Rundungs- oder Integer-Typecast-Funktion.
        
        Dass sprintf intern rundet habe ich nicht bestritten.
        
        Interessanter Thread: 991469
        die Drachin, Gwendolyn
        
        Unterschiedliche Perl-Versionen auf Windows (fast wie perlbrew) • Meine Perl-Artikel
- moritz
  
  2013-03-01 19:57
  User since
  2007-05-11
  923 Artikel
  HausmeisterIn
  Übrigens hat Perl 6 dafür auch eine schöne Lösung:
  
  Code: (dl )
  
  1 2
  
  $ perl6 -e 'say (19.9*100).Int' 1990
  
  Dezimalzahlen werden intern als Bruch gespeichert, deswegen sind die Berechnungen ohne Rundungsfehler.
  Perl 6 - Perls Zukunft
- +9 replies
- bianca
  
  2013-03-02 08:30
  
  User since
  2009-09-13
  6977 Artikel
  BenutzerIn
  
  2013-03-01T10:29:49 Rolf_PlusW
  nur die 19.9 macht Probleme.
  
  Wie du an meinem Code siehst kann man unendliche viele Beispiele bauen die Probleme machen.
  Dein Beispiel 19.9*100 wird mit meinem Code übrigens auch korrekt geint'et. Mit sprintf() zwar auch aber das hat wiederum andere Probleme. Bislang hat mein Code alle Beispiele überlebt und sich bei mir in der Praxis auch bewährt :)
  10 print "Hallo"
  20 goto 10
  - +8 replies
  - Gast wer
    
    2013-03-02 09:26
    Warum nur so kompliziert?
    
    Code (perl): (dl )
    
    1 2 3 4 5 6 7
    
    sub integer { my $wert = shift ( @_ ) || 0; return 0 if $wert =~ /e[+\-]?\d+$/; $wert=$1 if $wert =~ /^(.*?)\./; $wert=0 unless $wert; return $wert; }
    
    Last edited: 2013-03-02 09:58:37 +0100 (CET)
    - +7 replies
    - bianca
      
      2013-03-02 10:04
      
      User since
      2009-09-13
      6977 Artikel
      BenutzerIn
      
      Guest wer
      Warum nur so kompliziert?
      
      Fast.
      
      Quote
      '-0.903'...................geINTet mit PC : '0'........................
      '-0.903'...................geINTet mit gast_wer : '-0'.......................
      '-0.903'...................geINTet mit GUIfreund: '-1'.......................
      '-0.903'...................geINTet mit Bianca : '0'........................
      Erwartet '0'
      '1e+015'...................geINTet mit PC : '1e+015'...................
      '1e+015'...................geINTet mit gast_wer : '0'........................
      '1e+015'...................geINTet mit GUIfreund: '1000000000000000'.........
      '1e+015'...................geINTet mit Bianca : 'FEHLER'...................
      Erwartet 'FEHLER'
      
      Die restlichen Fälle machst du damit korrekt.
      10 print "Hallo"
      20 goto 10
      - gelöscht 2013-03-02 11:37
      - +5 replies
      - Gast wer
        
        2013-03-02 11:40
        
        Fehler im letzten Beitrag
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7 8
        
        sub integer { my $wert = shift ( @_ ) || 0; return 'FEHLER' if $wert =~ /e+?\d+$/; return 0 if $wert =~ /e-\d+$/; $wert=$1 if $wert =~ /^(.*?)\./; $wert=0 if !$wert or $wert == -0; return $wert; }
        
        Last edited: 2013-03-02 11:55:31 +0100 (CET)
        
        +4 replies
        
        bianca
        
        2013-03-02 12:22
        
        User since
        2009-09-13
        6977 Artikel
        BenutzerIn
        
        Hast noch einen Fehler im Regex für zu große Werte:
        
        Quote
        '1e+015'...................geINTet mit PC : '1e+015'...................
        '1e+015'...................geINTet mit gast_wer : '1e+015'...................
        '1e+015'...................geINTet mit GUIfreund: '1000000000000000'.........
        '1e+015'...................geINTet mit Bianca : 'FEHLER'...................
        Erwartet 'FEHLER'
        
        10 print "Hallo"
        20 goto 10
        
        +3 replies
        
        Gast wer
        
        2013-03-02 13:04
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7 8
        
        sub integer { my $wert = shift ( @_ ) || 0; return 'FEHLER' if $wert =~ /e\+?\d+$/; return 0 if $wert =~ /e-\d+$/; $wert=$1 if $wert =~ /^(.*?)\./; $wert=0 if !$wert or $wert == -0; return $wert; }
        
        Last edited: 2013-03-02 13:19:21 +0100 (CET)
        
        bianca
        
        2013-03-02 17:00
        
        User since
        2009-09-13
        6977 Artikel
        BenutzerIn
        
        Ja, nicht schlecht.
        Danke dir.
        10 print "Hallo"
        20 goto 10
        
        Gast Gast
        
        2013-03-02 17:33
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7 8 9 10 11 12 13 14
        
        use utf8; sub integer { my $wert = shift ( @_ ) || 0; return 'FEHLER' if $wert =~ /e\+?\d+$/; return 0 if $wert =~ /e-\d+$/; $wert=$1 if $wert =~ /^(.*?)\./; $wert=0 if !$wert or $wert == -0; return $wert; } print integer( 'e-߉' ), "\n"; # 0
        
        Last edited: 2013-03-02 17:35:47 +0100 (CET)
- Gast wer
  
  2013-03-02 17:28
  
  INT:
  Richtig INTen
  
  Runden:
  Kaufmännisch korrekt runden
  Kaufm. Runden
  Auf 2. Kommastelle runden?
  
  Alles Problem mit Float
  Last edited: 2013-03-02 17:35:58 +0100 (CET)
- +4 replies
- rosti
  
  2013-03-03 23:56
  
  User since
  2011-03-19
  3194 Artikel
  BenutzerIn
  
  Auch wenn ich jetzt nicht genau weiß, wass Deine Anforderungen sind und ob es dazu passt oder ob hier ein möglicher Bug vorliegt oder keiner:
  
  Für Berechnungen, die nur mit ganzen Zahlen gemacht werden müssen, nutze ich das Pragma use integer;
  
  Z.B. funktioniert die Berechnung fortlaufender Tage nach den Formeln von JJ Scaliger nur mit use integer, die Funktion int() ist hierfür völlig unbrauchbar. Dies ist mir auf die Füße gefallen, als ich vorn paar Jahren meine Kalender-Module geschrieben habe. Die Scaliger Formeln habe ich hier mal irgendwo gepostet.
  
  Des Weiteren arbeitet in PHP der (int) Cast genauso wie die int()-Funktion in Perl, als ich meine Perl-Klassen nach PHP portierte, habe ich das Pragma integer schmerzlich vermisst ;)
  
  Aber es gibt in PHP die Funktion floor(), will heißen: Es kommt für mich als Praktiker darauf an, was eigentlich gemacht werden soll und so habe ich meine Kalenderklassen auch in PHP erstklassig hinbekommen.
  
  Viele Grüße,
  Rolf
  - +3 replies
  - Raubtier
    
    2013-03-04 10:18
    User since
    2012-05-04
    1054 Artikel
    BenutzerIn
    
    2013-03-03T22:56:32 rosti
    Z.B. funktioniert die Berechnung fortlaufender Tage nach den Formeln von JJ Scaliger nur mit use integer, die Funktion int() ist hierfür völlig unbrauchbar.
    
    -v bitte
    
    Was kann use integer, das man nicht mit int nachbauen könnte? - Jetzt mal davon abgesehen davon, dass dein Wertebereich anders ist:
    
    Code: (dl )
    
    1 2 3 4
    
    $ perl -E'use integer;say 9223372036854775807+5' -9223372036854775804 $ perl -E'say 9223372036854775807+5' 9223372036854775812
    
    2013-03-03T22:56:32 rosti
    Es kommt für mich als Praktiker darauf an, was eigentlich gemacht werden soll
    
    Dem stimme ich zu.
    
    Ansonsten weiß ich nicht, was deine ständigen PHP-Vergleiche bringen sollen. Rechnen mit Gleitkommazahlen hat in allen Sprachen dieselben Probleme, sogar die Funktionen heißen oft ähnlich.
    - +2 replies
    - rosti
      
      2013-03-04 11:01
      
      User since
      2011-03-19
      3194 Artikel
      BenutzerIn
      
      Quote
      Ansonsten weiß ich nicht, was deine ständigen PHP-Vergleiche bringen sollen.
      
      Programmieren ist ein Handwerk und eine praktische Angelegenheit. Ich bin nicht der Einzige, der in mehreren Sprachen programmiert. Programmieren ist unabhängig von der Programmiersprache. Es kommt immer auf die Praxis an und auf die Anforderungen, die sich in der Praxis ergeben.
      
      Ich vermute (ganz stark!), dass sich hinter der Anforderung von Rolf+ eine praktische Angelegenheit verbirgt. D.h., dass es evntl. möglich ist, mit einer anderen Programmiersprache, wie zum Beispiel PHP, dieser Anforderung besser beikommen zu können.
      
      Sollte die Anforderung jedoch sein, einen Bug in Perl zu suchen, bin ich raus und bitte darum, meinen diesbezüglichen Beitrag zu entschuldigen.
      
      MfG
      - GwenDragon
        
        2013-03-04 11:20
        
        User since
        2005-01-17
        14533 Artikel
        Admin1
        
        2013-03-04T10:01:14 rosti
        Quote
        Ansonsten weiß ich nicht, was deine ständigen PHP-Vergleiche bringen sollen.
        
        (...)
        Ich vermute (ganz stark!), dass sich hinter der Anforderung von Rolf+ eine praktische Angelegenheit verbirgt. D.h., dass es evntl. möglich ist, mit einer anderen Programmiersprache, wie zum Beispiel PHP, dieser Anforderung besser beikommen zu können.
        Dann kann ich auch noch folgende zur Lösung aufbieten: COBOL, Fortran, Python, JSP oder Ruby.
        :)
        
        Es ist ja schön, dass du PHP kannst. Aber in einem Perl-Kontext (wohlgemerkt im Perl-Thread) mutet das immer seltsam an, wenn behauptet wird, in PHP ginge das auch (besser oder so).
        ;)
        
        Rolf_PlusW kann das sicher für dich erhellen, warum er nach einem Perl-Problem fragt.
        die Drachin, Gwendolyn
        
        Unterschiedliche Perl-Versionen auf Windows (fast wie perlbrew) • Meine Perl-Artikel

View all threads created 2013-03-01 11:29.