[erledigt->umgesetzt] Kann Filer die Datenrate /1000 statt /1024 berechnen?

[Homer]

@Elle4u: Zu meinem Vorschlag "Filer sollte bei der Berechnung der Datenrate 1000 statt 1024 verwenden" habe ich noch nichts von dir gelesen. Was ist deine Meinung? Sollte ich das bei SourceForge als Bug oder Feature Request eintragen?

Viele Grüße
Homer

[Elle4u]

[quote=""Homer""]@Elle4u: Zu meinem Vorschlag "Filer sollte bei der Berechnung der Datenrate 1000 statt 1024 verwenden" habe ich noch nichts von dir gelesen. Was ist deine Meinung? Sollte ich das bei SourceForge als Bug oder Feature Request eintragen?[/quote]

Pack es mal unter "Feature Request"

Ich hätte es schnell geändert, wenn es einfach gegangen wäre aber so ein feuriger Vogel hat da eine Meisterleistung an Berechnung walten lassen, welche ich nicht blicke .

Code: Alles auswählen

dword CalcDataRate64 (ulong64 *A, dword B)
{
  dword                 *AH, *AL, x;

  if (B == 0) return 0;

  AH = (dword *) &A [0];
  AL = AH + 1;

  //Convert into kB and multiply by 8
  SR64 (A, 7);

  //Divide with the time in seconds (B is the duration in minutes!)
  x = *AL / (B * 60);

  return x;
}

[Homer]

Wie ich das verstehe, wird A in ein Register kopiert, und durch 2**7 dividiert.

Code: Alles auswählen

 
//Convert into kB and multiply by 8
SR64 (A, 7);

Es folgt die Erklärung für obigen Code:
*2**-10 (B -> kB) und *2**3 (kB -> kb) -> *2**-7

Wenn man auf die Registerrechnung verzichtet hätte, wäre durch 128 zu teilen gewesen.
Nach meinem Vorschlag zukünftig dann durch 125. Zusammen mit der folgenden Division durch 60 ergibt sich in Zukunft eine Division durch ( 7500 * B ).

Viele Grüße
Homer

[Elle4u]

[quote=""Homer""]Wie ich das verstehe, wird A in ein Register kopiert, und durch 2**7 dividiert.
//Convert into kB and multiply by 8
SR64 (A, 7);
*2**-10 (B -> kB) und *2**3 (kB -> kb) -> *2**-7

Wenn man auf die Registerrechnung verzichtest hätte, wäre durch 128 zu teilen gewesen.
Nach meinem Vorschlag zukünftig dann durch 125. Zusammen mit der folgenden Division durch 60 ergibt sich in Zukunft eine Division durch ( 7500 * B ).[/quote]

Ich verstehe ehrlich gesagt nur Bahnhof ops:.

Was ist denn *2**-10 ?
2hoch2 - 10?

[Homer]

[quote=""Elle4u""]Was ist denn *2**-10 ?[/quote]"Mal (2 hoch -10)". Das ist gleich "geteilt durch (2 hoch 10)".

Viele Grüße
Homer

[Maliboy]

Und warum schreibt man das so und nicht einfach wie wir es in der Schule gelernt haben ?
Ich konnte nämlich mit der Formel auch nichts anfangen. Ich verstehe auch nicht, warum ich 2^10 nehmen soll. Ich weiß, das das 1024 sind. Aber muss das System so nicht zweimal rechnen ?

[Elle4u]

[quote=""Maliboy""]Und warum schreibt man das so und nicht einfach wie wir es in der Schule gelernt haben ?[/quote]

So kenne ich es auch. Das ^ als "hoch" und nicht **. Das hatte mich verwirrt.

[Skimble]

[quote=""Maliboy""]Ich verstehe auch nicht, warum ich 2^10 nehmen soll. Ich weiß, das das 1024 sind. Aber muss das System so nicht zweimal rechnen?[/quote]

Jein. Kommt auf den Compiler an. Wenn ich das richtig sehe, ist der TAP Compiler eine GCC Abart und der optimiert das weg, sprich es macht keinen Unterschied, ob ich da nun 2**10 oder 1024 hinschreibe.

2^10 kenne ich wiederum von keiner Programmiersprache, da wird das immer als 2**10 notiert.

[Elle4u]

[quote=""Skimble""]Jein. Kommt auf den Compiler an. Wenn ich das richtig sehe, ist der TAP Compiler eine GCC Abart und der optimiert das weg, sprich es macht keinen Unterschied, ob ich da nun 2**10 oder 1024 hinschreibe.

2^10 kenne ich wiederum von keiner Programmiersprache, da wird das immer als 2**10 notiert.[/quote]

OK. Danke.

[Maliboy]

[quote=""Skimble""]Jein. Kommt auf den Compiler an. Wenn ich das richtig sehe, ist der TAP Compiler eine GCC Abart und der optimiert das weg, sprich es macht keinen Unterschied, ob ich da nun 2**10 oder 1024 hinschreibe.[/quote]

Danke für den Hinweis. Trotzdem werden Gelegenheitsskripter/Programmierer dadurch verwirrt

[quote=""Skimble""]2^10 kenne ich wiederum von keiner Programmiersprache, da wird das immer als 2**10 notiert.[/quote]

Habe eben mal nachgeschaut: Perl schreibt auch 2**10. Da ich die Funktion aber noch nie benötigt habe, wusste ich es nicht. Also habe ich mal wieder etwas gelernt.
Ob mir dieses Wissen mal was bringen wird, wird sich zeigen. Werde wahrscheinlich weiterhin mit 1024 rechnen. Die Schreibweise 2^10 stammt halt noch aus der Schule und hat nichts mit programmieren zu tun.

[Skimble]

[quote=""Maliboy""]Trotzdem werden Gelegenheitsskripter/Programmierer dadurch verwirrt[/quote]

Das fällt in das Kapitel Jobsicherung.

[Elle4u]

[quote=""Skimble""]Das fällt in das Kapitel Jobsicherung.[/quote]

[Homer]

[quote=""Maliboy""]Ich verstehe auch nicht, warum ich 2^10 nehmen soll. Ich weiß, das das 1024 sind. Aber muss das System so nicht zweimal rechnen ?[/quote]Das soll man auch nicht nehmen. Das dient nur zur Erklärung des Codes SR64 ...

Viele Grüße
Homer

[FireBird]

Ich bin mir nicht sicher, ob unser gcc die 64-Bit-Arithmetic richtig beherrscht. Berechnungen mit 2er-Potenzen lassen sich durch Shift-Befehle ziemlich einfach auf eine beliebige Anzahl von Bits erweitern, was bei einer Division durch 1000 nicht mehr so trivial ist.

[MiK]

[quote=""Homer""]Das soll man auch nicht nehmen. Das dient nur zur Erklärung des Codes SR64 ...[/quote]
... welcher an dieser Stelle einfach nur die Binärzahl um 7 Stellen nach rechts schiebt, was noch wesentlich schneller geht als irgendwelche arithmetischen Operationen.

[Maliboy]

OT: Zwischenfrage von mir als Laie (auch wenn das hier schon mehr in einen Programmierkurs ausartet): SR64 (A, 7); sorgt dafür, das das Register Binär um 7 Stellen verschoben wird (also im Prinzip die letzten sieben stellen abgeschnitten werden) ? Das entspricht ein Teilen durch 128 mit nachträglicher Ganzzahl (ohne Runden). Habe ich das Richtig verstanden ? Das wiederum bedeutet, das ich den Befehl: Code: Alles auswählen SR64 (A, 7); durch Code: Alles auswählen A = A / 125 ; ersetzen könnte und die Berechnung würde stimmen. Oder ist es nicht so einfach, weil *AL ein Pointer ist, der auf das Register von A zugreift (oder verstehe ich den Teil auch verkehrt).

[Skimble]

[quote=""Maliboy""]
Das wiederum bedeutet, das ich den Befehl:

Code: Alles auswählen

SR64 (A, 7);

durch

Code: Alles auswählen

A = A / 125 ;

ersetzen könnte und die Berechnung würde stimmen. Oder ist es nicht so einfach, weil *AL ein Pointer ist, der auf das Register von A zugreift (oder verstehe ich den Teil auch verkehrt).
[/OT][/quote]

s/125/128/

[Maliboy]

[quote=""Skimble""]s/125/128/[/quote]

Um auf den Thread Titel zurückzukommen muss ich durch 125 Teilen. Wenn ich nur die Shift-Funktion ersetzen will, hast Du mit 128 recht

[MiK]

[quote=""Maliboy""]Zwischenfrage von mir als Laie (auch wenn das hier schon mehr in einen Programmierkurs ausartet):
SR64 (A, 7); sorgt dafür, das das Register Binär um 7 Stellen verschoben wird (also im Prinzip die letzten sieben stellen abgeschnitten werden) ?
Das entspricht ein Teilen durch 128 mit nachträglicher Ganzzahl (ohne Runden). Habe ich das Richtig verstanden ?[/quote]
ja

[quote=""Maliboy""]Das wiederum bedeutet, das ich den Befehl:

Code: Alles auswählen

SR64 (A, 7);

durch

Code: Alles auswählen

A = A / 125 ;

ersetzen könnte und die Berechnung würde stimmen. Oder ist es nicht so einfach, weil *AL ein Pointer ist, der auf das Register von A zugreift (oder verstehe ich den Teil auch verkehrt).
[/quote]
Wenn ich Firebird richtig verstanden habe, traut er dem GCC nicht zu richtig mit 64 Bit Zahlen zu rechnen.

[Maliboy]

[quote=""MiK""]Wenn ich Firebird richtig verstanden habe, traut er dem GCC nicht zu richtig mit 64 Bit Zahlen zu rechnen.[/quote]

Aber dann könnte man nie mir 1000 rechnen, oder ?