The Daily WTF

Er hat sich schon auf Seite 4 dazu geäußert.

Sgt. Nukem

Hier kommen noch'n paar gute:

Then of course there's Jared M who was surprised to see how his former coworker (with "over 15 years experience in the industry") negated numbers ...
if (trx.Amount < 0)
    trx.Amount = Math.Abs(trx.Amount);
else
    trx.Amount = Convert.ToDouble("-" + trx.Amount.ToString());

It seems everyone has their own way of finding a way to avoid multiplying numbers by -1. Shaun Katona's colleague demonstrates another YAWN (Yet Another Way to Negate) ...
int makeNegative( int n )
{
  int num;
  num = n - ( 2 * n );
  return num;
}

Response.Write LCase("SUBMIT ORDER")

IF (current_num - prev_num = current_num) THEN

Sovok

Sgt. Nukem schrieb:

It seems everyone has their own way of finding a way to avoid multiplying numbers by -1. Shaun Katona's colleague demonstrates another YAWN (Yet Another Way to Negate) ...
int makeNegative( int n )
{
  int num;
  num = n - ( 2 * n );
  return num;
}

öhm mit -1 multipliziern?
was hat er denn gegen

int makeNegative( int n )
{
  return -n;
}

SideWinder

*plonk* *schild an sovok überreich*

MfG SideWinder

imhotep

Sovok schrieb:

int makeNegative( int n )
{
  return -n;
}

Ein schönes Beispiel für übermässiges Refactoring.

Um richtig zu machen müsste man noch auf 0 testen

int makeNegative( int n )
{
  int num = 0;
  if (n<0) num = abs(n);
  else {
    if (n>0) num = ( 0 - 1 ) * abs(n);
    else {
      if (n == 0) num = 0;
    }
  }
  return num;
}

JBeni

IF (current_num - prev_num = current_num) THEN

Was soll daran schlecht sein? Wenn es um floats geht, ist das eine nette Methode rauszufinden, ob "prev_num" im Vergleich zu "current_num" nicht etwas gar klein ist

DEvent

JBeni schrieb:

IF (current_num - prev_num = current_num) THEN
Was soll daran schlecht sein? Wenn es um floats geht, ist das eine nette Methode rauszufinden, ob "prev_num" im Vergleich zu "current_num" nicht etwas gar klein ist

irre ich mich oder kann man den code ersetzen durch

if ( prev_num == 0 ) ...

groovemaster

JBeni schrieb:

Was soll daran schlecht sein?

Weil man dann gleich prüfen kann, ob prev_num gleich 0 ist.

JBeni schrieb:

Wenn es um floats geht, ist das eine nette Methode rauszufinden, ob "prev_num" im Vergleich zu "current_num" nicht etwas gar klein ist

Wenn du damit die Genauigkeit von Gleitkommazahlen meinst, dann macht man das aber anders und nicht mit Vergleich auf Gleichheit.

JBeni

groovemaster schrieb:

Wenn du damit die Genauigkeit von Gleitkommazahlen meinst, dann macht man das aber anders und nicht mit Vergleich auf Gleichheit.

Wie denn?
Solche Konstrukte werden doch angewendet, wenn z.B. die Wurzel von irgendwas berechnet werden soll. Die Abbruchbedingungen von Schleifen sind dann genau solche "Spielereien" mit der Genauigkeit der Zahlen.

groovemaster

SOLCHE Kontrukte werden eben nicht angewandt. Man überprüft, ob das Ergebnis (welches auch immer) innerhalb einer bestimmten Abweichung liegt. C bietet hier zB einen Epsilon Wert an. Die Überprüfung wird dann aber mit grösser bzw. kleiner (gleich) gemacht und nicht mit Überprüfung auf Gleichheit.

das ist doch alles zu 95% gefakt

volkard

groovemaster schrieb:

SOLCHE Kontrukte werden eben nicht angewandt. Man überprüft, ob das Ergebnis (welches auch immer) innerhalb einer bestimmten Abweichung liegt. C bietet hier zB einen Epsilon Wert an. Die Überprüfung wird dann aber mit grösser bzw. kleiner (gleich) gemacht und nicht mit Überprüfung auf Gleichheit.

dem muß ich nicht zustimmen.
ich hab gerade ein prog gebaut, das nullstellen von polynomen findet.
hab aber den feinen trick, um den es hier geht, noch nicht eingebaut.

das problem ist, daß ich, wenn die wurzel so um 1.414 liegt, ich bei diff=1.e-10 fein aufhören kann. aber wenn die wurzel so um 1.e-20 liegt, ich lieber bis 1.e-34 laufen mag.

...aufhören kann? irgendwann muß ich aufhören. einfach epsilon geht nicht, da ich auch mal gegen zyklen laufe, die keine kleineren beträge als 1.e-4 haben. wenn ich die würzeln des polynoms 1x^4+2x3+3x^2+4x+5 suche, dann fällt der rechner in einen zyklus der länge 84. ich hab nicht 84 speicherstellen zu verfügung. und der rechner ist auch so lahm, daß ich nicht do{a=f(a);b=f(f(b));}while(a!=b); schreiben mag wegen dreifachem rechenaufwand. ich überlege, ob ich brent's algo zweckentfremden kann zur zyklenerkennung und ob das billig ist. aber ungeachtet dessen, kann ich sofort abbrechen, wenn neuerwert-(neuerwert-alterwert)==neuerwert.

Sgt. Nukem

volkard schrieb:

das problem ist, daß ich, wenn die wurzel so um 1.414 liegt, ich bei diff=1.e-10 fein aufhören kann. aber wenn die wurzel so um 1.e-20 liegt, ich lieber bis 1.e-34 laufen mag.

...aufhören kann? irgendwann muß ich aufhören. einfach epsilon geht nicht, da ich auch mal gegen zyklen laufe, die keine kleineren beträge als 1.e-4 haben. wenn ich die würzeln des polynoms 1x^4+2x3+3x^2+4x+5 suche, dann fällt der rechner in einen zyklus der länge 84. ich hab nicht 84 speicherstellen zu verfügung. und der rechner ist auch so lahm, daß ich nicht do{a=f(a);b=f(f(b));}while(a!=b); schreiben mag wegen dreifachem rechenaufwand. ich überlege, ob ich brent's algo zweckentfremden kann zur zyklenerkennung und ob das billig ist. aber ungeachtet dessen, kann ich sofort abbrechen, wenn neuerwert-(neuerwert-alterwert)==neuerwert.

Ich glaube ich habe gerade meine neue Signatur gefunden...

JBeni

Doch noch was auf der HD gefunden: kein Grösser/Kleiner, kein Epsilon, und doch funktioniert die Wurzelberechnung

float value = 3;

        float top = value;
        float bottom = 0;

        float middle = bottom + (top - bottom)/2;

        while( top != middle && bottom != middle ){
            if( middle * middle > value )
                top = middle;
            else
                bottom = middle;

            middle = bottom + (top - bottom)/2;
        }

        System.out.printf( "sqrt %1$f = %2$f\n%2$f*%2$f = %3$f", 
                value, middle, middle*middle );

Wie das in irgendwelchen zutode optimierten c-libs aussieht, kann ich nicht sagen. Diese Variante mit der Maschinengenauigkeit umzugehen, ist jedenfalls ziemlich robust.

DEvent

wazu ist den das gut?

float value = 3; 

        float top = value; 
        float bottom = 0; 

        float middle = bottom + (top - bottom)/2;

wieso nicht gleich

float middle = value / 2;

lol, das ist schon echt auch WTF-verdächtig.

DEvent schrieb:

wazu ist den das gut?

float value = 3; 
        
        float top = value; 
        float bottom = 0; 
        
        float middle = bottom + (top - bottom)/2;

Ein compiler sollte das weg-optimieren. Aber zur Verstaendnis und einfacheren Lesbarkeit schadet es nicht. Im Gegenteil.
Und wie du unten siehst, werden die Variablen noch genutzt, ohne kommst du also eh nicht aus.

wieso nicht gleich
float middle = value / 2;

Wieso nicht gleich float middle = 3 / 2? value is auch konstant. Wenn du schon bei bist, koenntest du natuerlich gleich das Ergebnis des ganzen Algorithmus ausrechnen.

--
Andreas

Walli

Andreas Kohn schrieb:

wieso nicht gleich
float middle = value / 2;
Wieso nicht gleich float middle = 3 / 2?

Weil da nicht 1.5 rauskommt!

volkard

Walli schrieb:

Weil da nicht 1.5 rauskommt!

aber das programm funktioniert mit 2/3 auch!

int isTrueReturnsTrueIfTheArgumentIsTrueAndFalseIfItIsNotTrue(int t)
{
    //
}