Number.prototype.runden (round)

[Madokan]

Für die - die es ganz genau haben wollen - mit drei Rundungsmodis.

// --------------------------------------------------------------------
// Number.prototype.runden
// 
// Definition: zahl.runden(Rundungsmodus, DezimalZeichen, Genauigkeit)
// 
// pModus - Rundungsmodus (Auswahl: exc, dif, nat)
// pDezZeichen - Dezimal Trennzeichen
// pStellen - Prezision (Genauigkeit) - legt die Anzahl der Stellen nach dem Dezimalzeichen fest
// 
// Syntax: zahl_variable.runden("exc", ",", 2)
// 
// Anmerkung zu pModus - folgende Modien stehen zur Verfügung:
// "exc" :  (bsp: 10.1 -> 11 / 10.6 -> 11)
// "dif" :  (bsp: 10.8 -> 10 / 10.6 -> 10)
// "nat" :  (bsp: 10.1 -> 10 / 10.6 -> 11)
// 
// "exc" : ceil (Obergrenze - ist die nächstliegende Ganzzahl, die größer oder gleich der Zahl ist)
// "dif" : floor (Untergrenze - ist die nächstliegende Ganzzahl, die kleiner oder gleich der angegebenen Zahl ist)
// "nat" : round (Runden - rundet den Wert des Parameters x auf die nächstliegende Ganzzahl auf oder ab und gibt diese zurück)
// 
// ---------------------------------------------------------------------
 
Number.prototype.runden = function (pModus, pDezZeichen, pStellen)
{
    var prezision = Math.pow (10, pStellen);
    if (pModus == "exc")
    {
        var resultat = String (Math.ceil (this * prezision) / prezision);
    }
    else if (pModus == "dif")
    {
        var resultat = String (Math.floor (this * prezision) / prezision);
    }
    else if (pModus == "nat")
    {
        var resultat = String (Math.round (this * prezision) / prezision);
    }
    else
    {
        return "Fehler: Modus fehlt!";
    }
    var dezPunkt = resultat.indexOf (".");
    if (dezPunkt == -1)
    {
        resultat += ".";
        dezPunkt = resultat.length;
    }
    var dezZahl = resultat.substr (dezPunkt + 1);
    var i = dezZahl.length;
    while (i < pStellen)
    {
        resultat += "0";
        i++;
    }
    resultat = resultat.split (".").join (pDezZeichen);
    if (pDezZeichen != ",")
    {
        return Number (resultat);
    }
    return resultat;
};
 
// Verwenden - Beispiele
zahl_1 = 999.444536455;
zahl_2 = 999.444536455;
zahl_3 = 999.444536455;
zahl_4 = 999.44;
 
gerundet_1 = zahl_1.runden ("exc", ",", 2);
gerundet_2 = zahl_2.runden ("dif", ".", 3);
gerundet_3 = zahl_3.runden ("nat", ",", 3);
gerundet_4 = zahl_4.runden ("nat", ",", 3);
 
trace ("-----------------------------");
trace ("Zahl 1 original: " + zahl_1);
trace ("Zahl 1 gerundet: " + gerundet_1);
trace ("Zahl 2 original: " + zahl_2);
trace ("Zahl 2 gerundet: " + gerundet_2);
trace ("Zahl 3 original: " + zahl_3);
trace ("Zahl 3 gerundet: " + gerundet_3);
trace ("Zahl 4 original: " + zahl_4);
trace ("Zahl 4 gerundet: " + gerundet_4);
trace ("-----------------------------"); 

Hinweis
Läuft natürlich auch in Flash MX 2004!

Liebe Grüsse
Matze K.

[hgseib]

ein paar vorschläge dazu:

Number.prototype.runden = function(pModus, pDezZeichen, pStellen) {
    // wenn schon testen, dann vollstaendig ;-)
    if ("ceil-floor-round".indexOf(pModus) == -1) {
        return "runden-Fehler: unbekannter Modus!";
    }
    if (".,".indexOf(pDezZeichen) == -1) {
        return "runden-Fehler: unbekanntes DezZeichen!";
    }
    if (pStellen != Math.abs(int(pStellen))) {
        return "runden-Fehler: ungeeignete Stellenangabe!";
    }
    // warum neue namen fuer bekannte functionen ?
    var prezision = Math.pow(10, pStellen);
    var resultat = String(Math[pModus](this*prezision)/prezision);
    // pStellen == 0  beruecksichtigen
    if (pStellen) {
        // an e-darstellung keine nullen anhaengen
        if (resultat.lastIndexOf("e") == -1) {
            resultat += (resultat.indexOf(".") == -1) ? "." : "";
            var fuell = resultat.indexOf(".")-resultat.length+1+pStellen;
            while (fuell-->0) {
                resultat += "0";
            }
        }
    }
    return resultat.split(".").join(pDezZeichen);
};
// Verwenden - Beispiele
zahl_1 = -0.00123456789e-12;
zahl_2 = -123.456789;
zahl_3 = -0.35;
zahl_4 = 20;
trace("ceil : "+zahl_1.runden("ceil", ",", 0));
trace("floor: "+zahl_1.runden("floor", ".", 1));
trace("round: "+zahl_1.runden("round", ",", 20));
trace("ceil : "+zahl_2.runden("ceil", ",", 0));
trace("floor: "+zahl_2.runden("floor", ".", 4));
trace("round: "+zahl_2.runden("round", ",", 4));
trace("ceil : "+zahl_3.runden("ceil", ",", 0));
trace("floor: "+zahl_3.runden("floor", ".", 4));
trace("round: "+zahl_3.runden("round", ",", 4));
trace("ceil : "+zahl_4.runden("ceil", ",", 0));
trace("floor: "+zahl_4.runden("floor", ".", 4));
trace("round: "+zahl_4.runden("round", ",", 4));
trace("-----------------------------"); 

is nicht so einfach, hab noch einen fehler bei meinem AS entdeckt :-)

[hgseib]

".. Eier-legende-Wollmilchsau.."
den wolperdinger fängt man wohl nicht so schnell ;-) hab eben bei mir auch nachbessern müssen.

:-)))
und hecktig im gescripte ...

[Madokan]

@hgseib: Hatte auch noch mal deine Modifikation in die Mangel genommen. Die Anpassung gefällt mir gut - da hat sich jemand inspirieren lassen. Die Anpassung lastIndexOf ist jedoch unnötig - e gibt es nur einmal - nullen-->0 macht innerhalb der while-Schleife nicht wirklich sinn.

So ich hätte da auch noch einige Optimierungen und damit haben wir wohl die Eier-legende-Wollmilchsau - musste auch nochmals nachbessern - Nullenauffüllung ist was feines:

PHP-Code:

// --------------------------------------------------------------------
// Number.prototype.runden
//
// Definition: zahl.runden(Rundungsmodus, DezimalZeichen, Genauigkeit)
//
// pModus - Rundungsmodus (Auswahl: ceil, floor, round)
// pDezZeichen - Dezimal Trennzeichen
// pStellen - Prezision (Genauigkeit) - legt die Anzahl der Stellen nach dem Dezimalzeichen fest
//
// Syntax: zahl_variable.runden("ceil", ",", 2)
//
// Anmerkung zu pModus - folgende Modien stehen zur Verfügung:
// "ceil" :  (bsp: 10.1 -> 11 / 10.6 -> 11)
// "floor" :  (bsp: 10.8 -> 10 / 10.6 -> 10)
// "round" :  (bsp: 10.1 -> 10 / 10.6 -> 11)
//
// "ceil" : ceil (Obergrenze - ist die nächstliegende Ganzzahl, die größer oder gleich der Zahl ist)
// "floor" : floor (Untergrenze - ist die nächstliegende Ganzzahl, die kleiner oder gleich der angegebenen Zahl ist)
// "round" : round (Runden - rundet den Wert des Parameters x auf die nächstliegende Ganzzahl auf oder ab und gibt diese zurück)
//
// ---------------------------------------------------------------------
Number.prototype.runden = function(pModus, pDezZeichen, pStellen) {
    if ("ceil-floor-round".indexOf(pModus) == -1) {
        return "runden-Fehler: unbekannter Modus!";
    }
    if (".,".indexOf(pDezZeichen) == -1) {
        return "runden-Fehler: unbekanntes DezZeichen!";
    }
    // wenn schon Math.round - int veraltet schon seit Flash 5 ;-)
    if (pStellen != Math.abs(Math.round(pStellen))) {
        return "runden-Fehler: ungeeignete Stellenangabe!";
    }
    // warum unnötige Variablen ?
    var resultat = String(Math[pModus](this*Math.pow(10, pStellen))/Math.pow(10, pStellen));
    // logische Operatoren sind was feines.
    if (pStellen && resultat.indexOf("e") == -1) {
        resultat += (resultat.indexOf(".") != -1) ? "" : ".";
        var nullen = resultat.indexOf(".")-resultat.length+1+pStellen;            
        // nullen-->0 unnötig
        while (nullen--) {            
            resultat += "0";
        }
    }
    return resultat.split(".").join(pDezZeichen);
};

// Verwenden - Beispiele
// Positive Werte
zahl_1 = 999.444536455;
zahl_2 = 999.444536455;
zahl_3 = 999.444536455;
zahl_4 = 999.44;
gerundet_1 = zahl_1.runden("ceil", ",", 2);
gerundet_2 = zahl_2.runden("floor", ".", 3);
gerundet_3 = zahl_3.runden("round", ",", 3);
gerundet_4 = zahl_4.runden("round", ",", 3);

trace("-----------------------------");
trace("Zahl 1 original: "+zahl_1);
trace("Zahl 1 gerundet: "+gerundet_1);
trace("Zahl 2 original: "+zahl_2);
trace("Zahl 2 gerundet: "+gerundet_2);
trace("Zahl 3 original: "+zahl_3);
trace("Zahl 3 gerundet: "+gerundet_3);
trace("Zahl 4 original: "+zahl_4);
trace("Zahl 4 gerundet: "+gerundet_4);
trace("-----------------------------");

// Negative Werte + Auffüllung
zahl_1 = -0.00123456789e-12;
zahl_2 = -123.456789;
zahl_3 = -0.35;
zahl_4 = 20;

trace("ceil : "+zahl_1.runden("ceil", ",", 0));
trace("floor: "+zahl_1.runden("floor", ".", 1));
trace("round: "+zahl_1.runden("round", ",", 20));
trace("ceil : "+zahl_2.runden("ceil", ",", 0));
trace("floor: "+zahl_2.runden("floor", ".", 4));
trace("round: "+zahl_2.runden("round", ",", 4));
trace("ceil : "+zahl_3.runden("ceil", ",", 0));
trace("floor: "+zahl_3.runden("floor", ".", 4));
trace("round: "+zahl_3.runden("round", ",", 4));
trace("ceil : "+zahl_4.runden("ceil", ",", 0));
trace("floor: "+zahl_4.runden("floor", ".", 4));
trace("round: "+zahl_4.runden("round", ",", 4));
trace("-----------------------------"); 


Resultate:

-----------------------------
Zahl 1 original: 999.444536455
Zahl 1 gerundet: 999,45
Zahl 2 original: 999.444536455
Zahl 2 gerundet: 999.444
Zahl 3 original: 999.444536455
Zahl 3 gerundet: 999,445
Zahl 4 original: 999.44
Zahl 4 gerundet: 999,440
-----------------------------
ceil : 0
floor: -0.1
round: -1,23457e-15
ceil : -123
floor: -123.4568
round: -123,4568
ceil : 0
floor: -0.3500
round: -0,3500
ceil : 20
floor: 20.0000
round: 20,0000
-----------------------------

Be inspired...

Liebe Grüsse
Matze K.

[Madokan]

Und wenn wir schon dabei sind - hier noch etwas für die AS 2.0 Fans:

Runden.as - Datei:

PHP-Code:

// --------------------------------------------------------------------
// Klasse: Runden 
// 
// Definition: Runden.runden_extended(pZahl, Rundungsmodus, DezimalZeichen, Genauigkeit)
// 
// pZahl - zu rundende Zahl
// pModus - Rundungsmodus (Auswahl: ceil, floor, round)
// pDezZeichen - Dezimal Trennzeichen
// pStellen - Prezision (Genauigkeit) - legt die Anzahl der Stellen nach dem Dezimalzeichen fest
// 
// Syntax:
// gerundet_1 = Runden.runden_extended(zahl_1,"ceil", ",", 2);
// 
// Anmerkung zu pModus - folgende Modien stehen zur Verfügung:
// "ceil"  :  (bsp: 10.1 -> 11 / 10.6 -> 11)
// "floor" :  (bsp: 10.8 -> 10 / 10.6 -> 10)
// "round" :  (bsp: 10.1 -> 10 / 10.6 -> 11)
// 
// "ceil" : ceil (Obergrenze - ist die nächstliegende Ganzzahl, die größer oder gleich der Zahl ist)
// "floor" : floor (Untergrenze - ist die nächstliegende Ganzzahl, die kleiner oder gleich der angegebenen Zahl ist)
// "round" : round (Runden - rundet den Wert des Parameters x auf die nächstliegende Ganzzahl auf oder ab und gibt diese zurück)
// 
// ---------------------------------------------------------------------
class Runden extends Number {    
    static function runden_extended(pZahl:Number, pModus:String, pDezZeichen:String, pStellen:Number) {
        if ("ceil-floor-round".indexOf(pModus) == -1) {
            return "runden-Fehler: unbekannter Modus!";
        }
        if (".,".indexOf(pDezZeichen) == -1) {
            return "runden-Fehler: unbekanntes DezZeichen!";
        }
        if (pStellen != Math.abs(Math.round(pStellen))) {
            return "runden-Fehler: ungeeignete Stellenangabe!";
        }
        var resultat = String(Math[pModus](pZahl*Math.pow(10, pStellen))/Math.pow(10, pStellen));
        if (pStellen && resultat.indexOf("e") == -1) {
            resultat += (resultat.indexOf(".") != -1) ? "" : ".";
            var nullen = resultat.indexOf(".")-resultat.length+1+pStellen;
            while (nullen--) {
                resultat += "0";
            }
        }
        return resultat.split(".").join(pDezZeichen);
    }
} 


Aufruf im Flash Film:

PHP-Code:

// Verwenden - Beispiele
// Positive Werte
zahl_1 = 999.444536455;
zahl_2 = 999.444536455;
zahl_3 = 999.444536455;
zahl_4 = 999.44;
gerundet_1 = Runden.runden_extended(zahl_1, "ceil", ",", 2);
gerundet_2 = Runden.runden_extended(zahl_2, "floor", ".", 3);
gerundet_3 = Runden.runden_extended(zahl_3, "round", ",", 3);
gerundet_4 = Runden.runden_extended(zahl_4, "round", ",", 3);
trace("-----------------------------");
trace("Zahl 1 original: "+zahl_1);
trace("Zahl 1 gerundet: "+gerundet_1);
trace("Zahl 2 original: "+zahl_2);
trace("Zahl 2 gerundet: "+gerundet_2);
trace("Zahl 3 original: "+zahl_3);
trace("Zahl 3 gerundet: "+gerundet_3);
trace("Zahl 4 original: "+zahl_4);
trace("Zahl 4 gerundet: "+gerundet_4);
trace("-----------------------------");

// Negative Werte + Auffüllung
zahl_1 = -0.00123456789e-12;
zahl_2 = -123.456789;
zahl_3 = -0.35;
zahl_4 = 20;
trace("ceil : "+Runden.runden_extended(zahl_1, "ceil", ",", 0));
trace("floor: "+Runden.runden_extended(zahl_1, "floor", ".", 1));
trace("round: "+Runden.runden_extended(zahl_1, "round", ",", 20));
trace("ceil : "+Runden.runden_extended(zahl_2, "ceil", ",", 0));
trace("floor: "+Runden.runden_extended(zahl_2, "floor", ".", 4));
trace("round: "+Runden.runden_extended(zahl_2, "round", ",", 4));
trace("ceil : "+Runden.runden_extended(zahl_3, "ceil", ",", 0));
trace("floor: "+Runden.runden_extended(zahl_3, "floor", ".", 4));
trace("round: "+Runden.runden_extended(zahl_3, "round", ",", 4));
trace("ceil : "+Runden.runden_extended(zahl_4, "ceil", ",", 0));
trace("floor: "+Runden.runden_extended(zahl_4, "floor", ".", 4));
trace("round: "+Runden.runden_extended(zahl_4, "round", ",", 4));
trace("-----------------------------"); 


Liebe Grüsse
Matze K.

[hgseib]

// wenn schon Math.round - int veraltet schon seit Flash 5 ;-)
das ist nett, das MM das immer betont. aber haben die schon mal was rausgeschmissen? zum glück nicht.
z.b. das alte random ist besonders für spiele wesentlich besser. ist schneller und erzeugt integer. mir doch egal, ob Math.random bessere zufallszahlen liefert. int raus - ok

// warum unnötige Variablen ?
und
// logische Operatoren sind was feines.
da war mal was dazwischen gewesen ;-)
das teilen nach dem runden gefällt mir garnicht. im ungünstigsten fall könnten hier wieder nachkommastellen erzeugt werden. eigentlich bräuchte man doch nur noch im string das pDezZeichen zu plazieren.
ist aber aufwendiger als gedacht und da ich das mit den grummen zahlen hier nicht hinbekommen habe, hoffen wir das beste liebe leser ...
zusammen - ok

// warum unnötige Variablen ?
und
// logische Operatoren sind was feines
kostet wohl beides mehr zeit. d.h. bei den test's müsste ich erst testen. ist aber auch absolut minimal. ist ok
"..lastIndexOf ist jedoch unnötig - e gibt es nur einmal.."
ist schon klar, aber das e ist ganz hinten ;-) habs nicht getestet, aber eigentlich sollte diese routine von hinten beginnent suchen. (is ne krankheit, die hab ich noch aus der 6502-er zeit :-)


"..nullen-->0 macht innerhalb der while-Schleife nicht wirklich sinn.."
negativ!
da ich den test rausgenommen habe kann "nullen" kleiner null in die while- schleife gelangen. das kann dauern...
nee: wat mut dat mut
-----
nachtrag: ist immer so beim programmieren, jetzt wollte ich ein beispiel dazuschreiben, schliesslich ist mir das mit der endlosschleife passiert - aber nix is. ich bekomms nicht mehr hin.
also macht was ihr wollt ;-) mein rechner ist gerade fertig geworden, ich muss jetzt wieder malochen.

[Madokan]

"..nullen-->0 macht innerhalb der while-Schleife nicht wirklich sinn.."
negativ!
da ich den test rausgenommen habe kann "nullen" kleiner null in die while- schleife gelangen. das kann dauern...
nee: wat mut dat mut

nup dat mut nicht - schau mal hier:

PHP-Code:

zaehler = 10;
while (zaehler--) {
    trace(zaehler);
} 


Wie gut das 0 -> false entspricht und damit die Abbruchsbedingung automatisch auslöst.

---

Math.round ist schneller als int - hängt jedoch vom Flash Player ab - sprich 5 auf alle Fälle int bervorzugen - ab 6 und aufwärts Math.round.

---

// logische Operatoren sind was feines
kostet wohl beides mehr zeit. d.h. bei den test's müsste ich erst testen. ist aber auch absolut minimal. ist ok

Sehe ich auch so.

---

// logische Operatoren sind was feines.
da war mal was dazwischen gewesen ;-)
das teilen nach dem runden gefällt mir garnicht. im ungünstigsten fall könnten hier wieder nachkommastellen erzeugt werden. eigentlich bräuchte man doch nur noch im string das pDezZeichen zu plazieren.
ist aber aufwendiger als gedacht und da ich das mit den grummen zahlen hier nicht hinbekommen habe, hoffen wir das beste liebe leser ...
zusammen - ok

Keine Sorgen das Teilen wird keine Probleme bereiten - da ja der pStellen Parameter überprüft wird - hast doch extra in deiner if-Abfrage dafür gesorgt.

Anmerkung - du kannst ja auch malen - damit bist du Teilen los - ist jedoch unwesentlich - siehe bemerkung zur if-Abfrage:

PHP-Code:

var resultat = String(Math[pModus](this*Math.pow(10, pStellen))*Math.pow(0.1, pStellen)); 


Liebe Grüsse
Matze K.

[hgseib]

es ging um sowas:

zaehler = -10; 
while (zaehler--) { 
    trace(zaehler); 
} 

kommt jedoch nach ergänzung von
resultat += (resultat.indexOf(".") != -1) ? "" : ".";
nicht mehr vor.


"..Keine Sorgen das Teilen wird keine Probleme bereiten.."
ok, man wird/ist halt alt. mit sowas hatten computer mal probleme (testet man ja nicht jeden tag, ob's noch stimmt ;-):
1/3*3 != 1

deshalb sind solche beiträge auch zu was nütze.

[Madokan]

@hgseib: Ich denke auch einige andere Mitglieder werden ihre freude daran haben. Naja wie gesagt in letzter Zeit bleibt mir wenig Zeit für Spielerein, wie diese - aber mal so ein Skript hier und da haut schon hin.

Liebe Grüsse
Matze K.