Modulo falsch Berechnung?

[Th69]

Da du anscheinend das RAD Studio (AnsiString und ShowMessage), also den Embarcadero-Compiler, benutzt, könntest du auch den Datentyp System.Currency verwenden - dieser hat exakt 4 Nachkommastellen (ist dem Namen nach eigentlich für Währungen gedacht, aber auch für andere Anwendungsfälle, wie deinem, geeignet).

[Gestalt]

@Th69 also bei NTSC 23.976 benötige ich maximal 6 Nachkommastellen.
86313599.976024 = 999:59:59:999 h/m/s/ms

Dafür reicht dann aber int nicht mehr aus.

[Th69]

Ich schrieb ja auch int64_t.

Und für Fixpoint-Arithmetics habe ich auch noch Compositional Numeric Library (CNL) gefunden (dort kannst du dann die Anzahl der max. Nachkommastellen explizit angeben).

Auch wenn ich nicht verstehe, warum du bei Millisekunden-Genauigkeit mehr als 3 Nachkommastellen benötigst.

[Gestalt]

@Th69 Es geht auch mit 3 nur muss ich dann aufrunden.

[noLust]

@Th69 sagte in Modulo falsch Berechnung?:

int64_t time_in_milliseconds = frames * ms_per_s * 1001 / 24000;

Es ist besser, das ein wenig umzustellen:

int64_t time_in_milliseconds = (int64_t) (1001.0 / 24000.0 * frames * ms_per_s);

wobei es auch hierbei Ungenauigkeiten gibt: * und sogar / sind in diesem Fall Ungenauigkeitsbehaftet.

[Finnegan]

@Gestalt sagte in Modulo falsch Berechnung?:

Ich finde das nicht gut das man nach dem Sinn gefragt wird nur weil ich Dinge mache die eine anderer nicht macht und er deshalb darin keinen Sinn sieht.

Falls du es noch nicht mitbekommen haben solltest: Hier wird im Allgemeinen nicht nach dem "warum" gefragt, um jemanden auszulachen, sondern um besser helfen zu können.

[Gestalt]

@Finnegan sagte in Modulo falsch Berechnung?:

ch dem "warum" ge

Ich weiß wie Menschen sind, hatte mein ganzes leben lang Zeit sie zu analysieren mir brauch keiner was von alle sind so lieb erzählen. Es gibt Ausnahmen die sind aber wirklich selten.

[Finnegan]

@noLust sagte in Modulo falsch Berechnung?:

@Th69 sagte in Modulo falsch Berechnung?:

int64_t time_in_milliseconds = frames * ms_per_s * 1001 / 24000;

Es ist besser, das ein wenig umzustellen:

int64_t time_in_milliseconds = (int64_t) (1001.0 / 24000.0 * frames * ms_per_s);

wobei es auch hierbei Ungenauigkeiten gibt: * und sogar / sind in diesem Fall Ungenauigkeitsbehaftet.

Und was ist daran nun "besser"? Die Integer-Berechnung war immer auf volle, "abgelaufene" Millisekunden genau, egal wie viele Frames man hat (Fehler $\lt$ 1ms). mit diesen double kann der Fehler jetzt abhängig von (großem) frames nahezu beliebig groß werden.

[Gestalt]

@noLust

int64_t time_in_milliseconds = (int64_t) (1001.0 / 24000.0 * 47.952 * 1000);  //muss sein 2000 ist aber 1999

also so gehts nicht, weil das "47.952" 2sekunden bzw. 2000ms sind
da bleib ich doch liebers bei meiner Variante.

[noLust]

@Finnegan Ich hab da auch noch ein round vergessen

@Gestalt sagte in Modulo falsch Berechnung?:

Es gibt Ausnahmen die sind aber wirklich selten.

Na ja, irgendwie kaufe ich dir die Unschuldslammnummer auch nicht so ganz ab.

[Gestalt]

@noLust naja ich weiß nicht nicht wie ich sagen soll aber ich bin nicht wie ihr, ich hab mit dem allem was sich da als Menschen bezeichnen nix gemeinsames, und das ist auch gut so.

[Gestalt]

@noLust

int64_t time_in_milliseconds = (int64_t) round((1001.0 / 24000.0 * 47.952 * 1000));  //muss sein 2000

if(time_in_milliseconds == 2000)
 cout << "it's true" <<endl;

[noLust]

Sag ich doch auch ... ich bin der beste.

[Gestalt]

@noLust nicht schlecht

[noLust]

Aber sogar ich musste gerade googeln, ob man das groß- bzw. kleinschreibt ...

Ich bin der Beste - ist richtig. Der Duden drückt sich da aber widersprüchlich aus, so ist:

• dieser Wein ist der beste
• er ist der Beste in der Klasse

beides richtig. Ich möchte gar nicht wissen, wer das wieder verbockt hat.

Edit: Na klar, Ersteres bezieht sich nur auf alle Weine - aber man möchte ja ausdrücken, dass man absolut der Beste ist, also ohne eine Einschränkung der Menge.

[Gestalt]

@noLust aber ich muss Dich da enttäuschen ist wahrscheinlich falsch gerundet denn

int64_t time_in_milliseconds = (int64_t) round((1001.0 / 24000.0 * 47.951* 1000));  //muss sein 1999 ist aber 2000

[noLust]

Nö: https://www.wolframalpha.com/input?i=1001.0+%2F+24000.0+*+47.951+*+1000

[noLust]

@Gestalt Schau hier mal nach: https://en.cppreference.com/w/cpp/numeric/math/floor

[Gestalt]

@noLust

int64_t time_in_milliseconds = (int64_t) std::floor( ((1001.0 / 24000.0 * 47.951 * 1000)) + 0.01); muss sein 1999

int64_t time_in_milliseconds = (int64_t) std::floor( ((1001.0 / 24000.0 * 47.952 * 1000)) + 0.01); muss sein 2000

geht ob es aber zuverlässig läuft keine Ahnung, vermutlich nicht habs mal im ms-Bereich getestet da gehts dann nicht, die Rundung ist zu scharf.

[Gestalt]

Nochmals zum Abschluss bester Code

double maxtime;
double frames=130908.936024; //01:30:59.999				
maxtime = frames / aFramesPerSec * 1000;   //aFramesPerSec=23.976
maxtime = std::floor(maxtime + 0.00001);

oder eben auch so, da ja eine Ganz-Zahl zurückgegeben wird

double frames=130908.936024; //01:30:59.999
int64_t time_in_milliseconds = std::floor((frames / default_aFramesPerSec * 1000)+0.00001); //aFramesPerSec=23.976