Richtig INTen (gelöst) (Allgemeines zu Perl) - Perl-Community.de

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

2024-12-23 02:33:32
Europe/Berlin
Einloggen (Registrieren)
- Einstellungen
- Statistics
Jemand zu Hause?
0 Benutzer online
1 Gast

[thread]14409[/thread]

submit to reddit

Richtig INTen [gelöst]

[gelöst]

Leser: 39

Articles: hide open all | hide show old branches

+15 replies
bianca

2009-12-24 09:27
User since
2009-09-13
7016 Artikel
BenutzerIn
Erstmal fettes FROHE WEIHNACHTEN an alle!
Und dann noch ein kleines Problemchen wo ich um Hilfe bitte.
Ich möchte Werte richtig "INTen" und zwar nicht mit int(), denn das macht nicht immer, was ich möchte.

Mein Versuchsaufbau:
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

my $sub = 'integer1'; my $space = '.' x 25; my ($int,$erwartet); foreach my $test ( .57 * 100,'=57', .58,'=0', 12.345,'=12', 57.00000000000000001,'=57', 0.000000000000001,'=0', 1.01205,'=1', -0.903,'=0', -1.999999999999999,'=-1' ) { if (substr ($test,0,1) eq '=') { $erwartet = substr ($test,1); print " " . ($int eq $erwartet ? ' OK' : " FEHLER! Erwartet \'$erwartet\'") . "\n"; } else { $int = &{$sub} ($test); print "\'$test\'" . substr ($space,0,25 - length ($test)) . "geINTet: \'$int\'" . substr ($space,0,25 - length ($int)); } }
Testfall Perl's int():
Code (perl): (dl )

1 2 3

sub intperl { return int($_[0]); }
Ergibt:
Code: (dl )

1 2 3 4 5 6 7 8

'57'.......................geINTet: '56'....................... FEHLER! Erwartet '57' '0.58'.....................geINTet: '0'........................ OK '12.345'...................geINTet: '12'....................... OK '57'.......................geINTet: '57'....................... OK '1e-015'...................geINTet: '0'........................ OK '1.01205'..................geINTet: '1'........................ OK '-0.903'...................geINTet: '0'........................ OK '-2'.......................geINTet: '-1'....................... OK
Macht Fehler bei .57 * 100 und vermutlich auch noch bei anderen Berechnungen.

Testfall integer1:
Code (perl): (dl )

1 2 3 4 5 6 7

sub integer1 { my $wert = shift ( @_ ) || 0; if ($wert =~ /^([^\.]*)\.([^\.]+)$/) { $wert = $1; } return $wert + 0; }
Ergibt:
Code: (dl )

1 2 3 4 5 6 7 8

'57'.......................geINTet: '57'....................... OK '0.58'.....................geINTet: '0'........................ OK '12.345'...................geINTet: '12'....................... OK '57'.......................geINTet: '57'....................... OK '1e-015'...................geINTet: '1e-015'................... FEHLER! Erwartet '0' '1.01205'..................geINTet: '1'........................ OK '-0.903'...................geINTet: '0'........................ OK '-2'.......................geINTet: '-2'....................... FEHLER! Erwartet '-1'
Macht also Fehler bei -1.999999999999999 und 0.000000000000001.

Und die gleichen Fehler habe ich bei diesem Ansatz:
Code (perl): (dl )

1 2 3 4 5 6 7 8 9 10 11 12 13

sub integer2 { my $wert = shift ( @_ ) || 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; } return $wert + 0; }
Hat jemand noch Ideen, wie ich alle drei Fälle "fehlerfrei" inten kann?

Danke und frohes Fest!
Last edited: 2009-12-24 09:28:04 +0100 (CET)
10 print "Hallo"
20 goto 10
- +3 replies
- moritz
  
  2009-12-24 10:22
  User since
  2007-05-11
  923 Artikel
  HausmeisterIn
  Dein Problem ist nicht das runden, sondern Fließkommazahlen: 0.57 * 100 ist eben nicht 57, wenn man in Fließkommazahlen rechnet.
  
  Du kannst das Problem nicht mit runden lösen, nur darum herum fuhrwerken:
  
  Code (perl): (dl )
  
  1 2 3
  
  sub integer1 { int($_[0]+ 1e-5); }
  
  Das besteht alle deine Tests, kann aber die prinzipiellen Beschränkungen durch Fließkommazahlen natürlich nicht aufheben.
  Perl 6 - Perls Zukunft
  - betterworld
    
    2009-12-24 13:29
    
    User since
    2003-08-21
    2614 Artikel
    ModeratorIn
    
    Math::BigRat könnte auch helfen.
    Lieblingsmodule: IPC::System::Simple, Path::Class
  - GUIfreund
    
    2012-01-17 19:49
    User since
    2011-08-08
    559 Artikel
    BenutzerIn
    
    2009-12-24T09:22:41 moritz
    
    Code (perl): (dl )
    
    1 2 3
    
    sub integer1 { int($_[0]+ 1e-5); }
    
    Das funktioniert so nur für positive Zahlen.
    Gruß
    GUIfreund
- pq
  
  2009-12-24 15:29
  
  User since
  2003-08-04
  12208 Artikel
  Admin1
  
  Test::More will irgendwie nicht so richtig an dich, was? =)
  Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live. -- Damian Conway in "Perl Best Practices"
  lesen: Wie frage ich & perlintro brian's Leitfaden für jedes Perl-Problem
- Gast LanXoff
  
  2009-12-25 02:23
  
  und immer immer wieder geht die Sonne auf...
- +8 replies
- bianca
  
  2012-01-17 08:32
  User since
  2009-09-13
  7016 Artikel
  BenutzerIn
  Hab es im Moment so implementiert. Deckt auch den .57*100 Fall ab.
  
  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
  - +7 replies
  - GUIfreund
    
    2012-01-17 13:17
    User since
    2011-08-08
    559 Artikel
    BenutzerIn
    
    Einfacher geht's so:
    
    Code (perl): (dl )
    
    1 2 3
    
    sub mit_sprintf { return int(sprintf '%.15f', $_[0]); }
    
    Gruß
    GUIfreund
    - +6 replies
    - bianca
      
      2012-01-17 14:32
      
      User since
      2009-09-13
      7016 Artikel
      BenutzerIn
      
      Ja, wenn es so einfach wäre....
      
      Code (perl): (dl )
      
      print int(sprintf '%.15f', .57*100);
      
      Quote
      56
      
      Passt nicht ganz.
      Ich weiß, das ist kein Problem von int() aber irgendwo muss man die Rechenfehler ja "beheben", daher schicke ich solche Rechnungen alle durch meine obige integer() Routine.
      10 print "Hallo"
      20 goto 10
      - +5 replies
      - GUIfreund
        
        2012-01-17 19:12
        
        User since
        2011-08-08
        559 Artikel
        BenutzerIn
        
        2012-01-17T13:32:13 bianca
        Ja, wenn es so einfach wäre....
        
        Code (perl): (dl )
        
        print int(sprintf '%.15f', .57*100);
        
        Quote
        56
        
        Passt nicht ganz.
        
        Da hast du mich ja ganz schön ins Bockshorn gejagt. Dein Beispiel ist richtig. Und es kann auch gar nicht anders sein, denn
        
        Code (perl): (dl )
        
        perl -e "printf '%.15f', .57 * 100"
        
        ergibt 56.999999999999993. Ich habe nie etwas anderes behauptet. Ich habe nur gesagt, dass meine sub mit_sprintf beim Testfall
        Quote
        .57 * 100,'=57',
        das richtige Resultat liefert. Und das stimmt nach wie vor. Es kann auch gar nicht anders sein, denn in deinem Testskript (aus dem OP) wird an die sub $sub der exakte Wert 57 übergeben. Da kann int() nichts verderben.
        
        Bleibt die Frage, wieso deine sub intperl in diesem Testfall 56 liefert. Die Antwort ist einfach: sie liefert das richtige 57.
        
        Übrigens wird auch in den Testfällen
        Quote
        57.00000000000000001,'=57',
        -1.999999999999999,'=-1',
        
        der exakte Wert 57 bzw. 2 an die sub $sub übergeben. In letzterem Fall arbeitet nicht int falsch, sondern dein Erwartungswert ist falsch.
        
        Bist du jetzt verwirrt? Ich auch. Als mögliche Erklärungen habe ich anzubieten: andere Hardware, anderes OS, andere Perl-Version.
        Gruß
        GUIfreund
        
        +4 replies
        
        bianca
        
        2012-01-17 19:29
        
        User since
        2009-09-13
        7016 Artikel
        BenutzerIn
        
        2012-01-17T18:12:29 GUIfreund
        Ich habe nur gesagt, dass meine sub mit_sprintf beim Testfall
        Quote
        .57 * 100,'=57',
        das richtige Resultat liefert. Und das stimmt nach wie vor.
        
        Ja, eine Spitzfindigkeit. Klar liefert es das "richtige" Ergebnis. Aber es bringt mir ja nichts, wenn das computerrichtige Ergebnis mathematischer Nonsens ist. 0.57 * 100 ist nun mal nicht 56 sondern 57, egal ob ich das int'e oder nicht :))
        Ich schrieb ja auch, dass es kein primäres int Problem ist. Aber man muss ja trotzdem die Rechenschwächen irgendwann oder irgendwo ausgleichen.
        
        2012-01-17T18:12:29 GUIfreund
        Es kann auch gar nicht anders sein, denn in deinem Testskript (aus dem OP) wird an die sub $sub der exakte Wert 57 übergeben. Da kann int() nichts verderben.
        
        Auf meinen Systemen ist es egal, ob ich es in die sub übergebe oder direkt einsetze, es kommt immer 56 raus und das ist und bleibt für mich "falsch". Und ich weiß auch nicht, in welchem Zusammenhang man dieses Ergebnis berechtigterweise als richtig bezeichnen könnte. Sein Zustandekommen mag erklärbar sein, das macht es aber deshalb nicht richtiger :)
        Und am Ende wollte ich nicht nachweisen, dass int etwas verdirbt sondern ich nutze das int'en mit eigener Routine eben an einigen Stellen zur Korrektur falscher Ergebnisse.
        
        Ist halt tückisch. Auf den ersten Blick übergibst du .57*100 an int() und es kommt 56 raus. Rechnest du ohne int() kommt 57 raus, siehe hier:
        
        Code (perl): (dl )
        
        1 2
        
        print "int : ".(int(.57*100))."\n"; print "ohne: ".(.57*100)."\n";
        
        Quote
        int : 56
        ohne: 57
        
        Was ist zuerst verdächtig? Klar, kann nur int() sein. Wenn man tiefer schaut natürlich nicht, denn int() bekommt ja schon Nonsens geliefert. Jetzt kann man auf zweierlei Arten reagieren: Entweder du rufst nach jeder Rechenoperation mit Kommazahlen eine Korrekturroutine auf oder du machst es kombiniert mit int().
        Und die Korrekturroutine ist ja nicht ganz trivial, da der PC seine eigenen Fehler nicht beheben kann. Also mache ich int(), denn ich weiß ja meistens, wieviele Stellen ich brauche. Also vorher Komma verschieben, int'en und Komma wieder zurück.
        Vom Code her erscheint mir das als einer der einfachsten Wege, dem PC das korrekte Rechnen beizubringen :)
        
        Editiert von bianca: Textergänzung
        
        Editiert von bianca: Code ergänzt
        Last edited: 2012-01-17 19:55:08 +0100 (CET)
        10 print "Hallo"
        20 goto 10
        
        +3 replies
        
        GUIfreund
        
        2012-01-20 17:48
        
        User since
        2011-08-08
        559 Artikel
        BenutzerIn
        
        2012-01-17T18:29:18 bianca
        2012-01-17T18:12:29 GUIfreund
        Ich habe nur gesagt, dass meine sub mit_sprintf beim Testfall
        Quote
        .57 * 100,'=57',
        das richtige Resultat liefert. Und das stimmt nach wie vor.
        
        Ja, eine Spitzfindigkeit. Klar liefert es das "richtige" Ergebnis. Aber es bringt mir ja nichts, wenn das computerrichtige Ergebnis mathematischer Nonsens ist. 0.57 * 100 ist nun mal nicht 56 sondern 57, egal ob ich das int'e oder nicht :))
        
        Beim Lesen deiner Antwort bekam ich den Eindruck, dass du glaubst, mit "das richtige Resultat" hätte ich 56 gemeint. Ich hätte genauer "das von dir erwartete Resultat" schreiben sollen. Entschuldige bitte.
        
        2012-01-17T18:29:18 bianca
        Auf den ersten Blick übergibst du .57*100 an int() und es kommt 56 raus. Rechnest du ohne int() kommt 57 raus, siehe hier:
        
        Code (perl): (dl )
        
        1 2
        
        print "int : ".(int(.57*100))."\n"; print "ohne: ".(.57*100)."\n";
        
        Quote
        int : 56
        ohne: 57
        
        2012-01-17T18:29:18 bianca
        Rechnest du ohne int() kommt 57 raus
        
        Das sieht nur so aus. Wie ich schon früher schrieb, ergibt .57*100 auf meinem PC 56.999999999999993. (Das ist übrigens nicht falsch, sondern ungenau. Hoffentlich hältst du das nicht wieder für spitzfindig.) Auf deinem Rechner kann das Ergebnis der Multiplikation anders als bei mir sein, ist aber offenbar ebenfalls zu klein. print() rundet dann - rundet anders als int() - und liefert 57.
        
        int() rundet durch Abschneiden der Nachkommastellen. Da es dir beim Runden darauf ankommt, Ungenauigkeiten der Hardware-Arithmetik auszubügeln (also Zahlen zu runden, die meistens fast ganzzahlig sind), wirst du mit Runden zur nächstliegenden ganzen Zahl wohl mehr Erfolg haben. Das kannst du in Perl z. B. auf folgende Weisen erreichen:
        
        Code (perl): (dl )
        
        1 2
        
        my $rund = sprintf '%.0f', $wert); my $rund = int($wert + 0.5);
        
        Probier's mal aus.
        Gruß
        GUIfreund
        
        +2 replies
        
        topeg
        
        2012-01-20 19:14
        
        User since
        2006-07-10
        2611 Artikel
        BenutzerIn
        
        Die Probleme tauchen immer auf, wenn Fließkommazahlen in Integer umgewandelt werden sollen. int ist hier nur ein Beispiel. Beim Runden passiert genau das selbe.
        Das tritt in deinem Fall nur deshalb nicht auf, da mit Zahlen gearbeitet wird, die nahe an einem Integer sind.
        Nimmt man andere Werte, so taucht das Problem auch wieder auf. Deine Form des Rundens ebenfalls ist nicht zuverlässig. Auch dort kann es zu Fehlern kommen, wenn eine Rationale Zahl als Fließkommazahl nicht darstellbar ist. So was kann man umgehen. So ist es möglich einigermaßen Korrekt zu runden, indem man die Genauigkeit der Darstellung erhört. Das habe ich z.B bei meiner Funktion zum Runden gemacht. Ähnliches kann man auch bei der von bianca angesprochenen Multiplikation mit Integerumwandlung machen.
        
        Gäbe es einfache Lösungen die Schwächen des Computers zu umgehen, so würde ich sie nutzen. Aber einfache Lösungen gibt es nur in Spezialfällen. Generell muss man größeren Aufwand treiben.
        
        EDIT:
        Wobei int($wert*100) ein solcher Spezialfall ist. Da kann man schreiben int($wert*100+0.001) damit werden zu kleine Werte "angehoben". Insofern hast du Recht. Das lässt sich aber nicht so einfach generalisierten.
        Last edited: 2012-01-20 19:25:23 +0100 (CET)
        
        GUIfreund
        
        2012-01-21 10:14
        
        User since
        2011-08-08
        559 Artikel
        BenutzerIn
        
        2012-01-20T18:14:29 topeg
        Die Probleme tauchen immer auf, wenn Fließkommazahlen in Integer umgewandelt werden sollen. int ist hier nur ein Beispiel. Beim Runden passiert genau das selbe.
        Das tritt in deinem Fall nur deshalb nicht auf, da mit Zahlen gearbeitet wird, die nahe an einem Integer sind.
        
        Und selbst wenn die Zahl nahe an einem Integer liegt, heißt das nicht, dass dies die richtige Integer ist. Durch instabile Algorithmen können sich Rundungsfehler gewaltig aufblähen und das Ergebnis unbrauchbar machen. Es sollen dadurch schon Brücken eingestürzt sein.
        
        2012-01-20T18:14:29 topeg
        Nimmt man andere Werte, so taucht das Problem auch wieder auf. Deine Form des Rundens ebenfalls ist nicht zuverlässig. Auch dort kann es zu Fehlern kommen, wenn eine Rationale Zahl als Fließkommazahl nicht darstellbar ist. So was kann man umgehen. So ist es möglich einigermaßen Korrekt zu runden, indem man die Genauigkeit der Darstellung erhört. Das habe ich z.B bei meiner Funktion zum Runden gemacht. Ähnliches kann man auch bei der von bianca angesprochenen Multiplikation mit Integerumwandlung machen.
        
        Gäbe es einfache Lösungen die Schwächen des Computers zu umgehen, so würde ich sie nutzen.
        
        ... und die Hardware-Hersteller auch.
        
        2012-01-20T18:14:29 topeg
        Aber einfache Lösungen gibt es nur in Spezialfällen. Generell muss man größeren Aufwand treiben.
        
        EDIT:
        Wobei int($wert*100) ein solcher Spezialfall ist. Da kann man schreiben int($wert*100+0.001) damit werden zu kleine Werte "angehoben". Insofern hast du Recht. Das lässt sich aber nicht so einfach generalisierten.
        
        Du rennst bei mir offene Türen ein. Ich bin mit der Problematik der Genauigkeit von Gleitkommaarithmetik recht gut vertraut. Ein Computer kann nur endlich viele Zahlen exakt darstellen. Man kann mit Computern sehr genau rechnen. Z. B. wurde π (pi) schon sehr genau berechnet. Man muss sich aber vorher (!!!!) überlegen, welche Genauigkeit man benötigt, und sein Programm entsprechend auslegen.
        Gruß
        GUIfreund
- rosti
  
  2012-01-21 10:34
  User since
  2011-03-19
  3492 Artikel
  BenutzerIn
  Bis 15 Nachkommastellen tut das hier:
  
  Code (perl): (dl )
  
  1 2
  
  my $i = 5.999999999999999; print unpack "i", pack "i", $i; # 5
  
  Nachteil: Ab der 16. Nachkommastelle (alle mit Wert "9") wird aufgerundet.

View all threads created 2009-12-24 09:27.