std.math — Mathematik

→ Zurück zur Unit-Übersicht

Mathematische Grundfunktionen in zwei Schichten: Ganzzahl-Mathematik (Betrag, Min/Max, Wurzel, Potenz, Interpolation, Zahlentheorie) und f64-Mathematik (Wurzel, Trigonometrie, Exponential- und Logarithmusfunktionen). Die Ganzzahl-Schicht rechnet ohne Fließkomma und ist damit auch auf Zielen ohne FPU einsetzbar; die f64-Schicht setzt auf den Gleitkomma-Builtins fAdd/fSub/fMul/fDiv/sqrt auf.

Einsatzbereiche: Geometrie, Skalierung von Messwerten, Animationen, Hashing, Speicherverwaltung (Zweierpotenzen), Statistik-Grundlagen. Basis-Unit für std.vector, std.rect, std.circle.

Autor: Andreas Röne
Copyright: 2024–2025 Andreas Röne
Quelle: std/math.lyx

<WRAP info> Seit lyxc 1.0.20F sind die früher hier verzeichneten Rechenfehler behoben (#1444–#1450). Nachgemessen:

Sin64(30°)  = 500000        Hypot64(3,4) = 5
Sin64(90°)  = 1000000       IsOdd(-3)    = 1
Cos64(60°)  = 500000        PopCount(-1) = 64

Die Winkelfunktionen rechnen in Mikrograd. Sin64(30000000) ist der Sinus von 30°, das Ergebnis ist mit 1.000.000 skaliert. Wer die alte Annahme „Grad rein, Promille raus„ übernimmt, bekommt für Sin64(30) eine 0 — das sind 30 Mikrograd, also praktisch null Grad. </WRAP>

import std.math;

Diese Gruppe rechnet Winkel als Mikrograd (1° = 1 000 000) und Funktionswerte als Festkomma mit Faktor 1 000 000 (1,0 = 1 000 000).

Die zugrunde liegenden Random() und RandomSeed(n) sind Compiler-Builtins, keine Funktionen dieser Unit.

Alle Winkel im Bogenmaß.

Seit dem Fix von #1449 sind alle vier über den ganzen Wertebereich brauchbar — geprüft: ExpF64(5) = 148.413159, LogF64(100) = 4.605170, PowF64(2, 10) = 1024.000000. Die verbleibende Abweichung liegt bei rund einer Millionstel.

Zu beachten bleibt: LogF64(x ⇐ 0) gibt −1.0 als Fehlerkennung zurück — das ist zugleich ein gültiges Ergebnis (ln(1/e) = −1), Fehler und Resultat sind also nicht unterscheidbar.

import std.math;

fn main(): int64 {
    // Ganzzahl-Grundlagen
    PrintLn("Abs64(-42)        = ", IntToStr(Abs64(-42)));
    PrintLn("Sign64(-7)        = ", IntToStr(Sign64(-7)));
    PrintLn("Clamp64(150,0,100)= ", IntToStr(Clamp64(150, 0, 100)));
    PrintLn("InRange64(50,0,100)= ", IntToStr(InRange64(50, 0, 100) as int64));
    PrintLn("Min3(9,4,7)       = ", IntToStr(Min3(9, 4, 7)));
    PrintLn("Max3(9,4,7)       = ", IntToStr(Max3(9, 4, 7)));

    // Wurzel, Potenz, Logarithmus
    PrintLn("Sqrt64(1000000)   = ", IntToStr(Sqrt64(1000000)));
    PrintLn("Sqrt64(10)        = ", IntToStr(Sqrt64(10)), "   (floor)");
    PrintLn("Pow64(2,10)       = ", IntToStr(Pow64(2, 10)));
    PrintLn("Log2(1024)        = ", IntToStr(Log2(1024)));
    PrintLn("Log2(1000)        = ", IntToStr(Log2(1000)), "     (floor)");

    // Skalierung
    PrintLn("Lerp64(100,200,500)      = ", IntToStr(Lerp64(100, 200, 500)));
    PrintLn("Map64(512,0,1023,0,100)  = ", IntToStr(Map64(512, 0, 1023, 0, 100)));
    return 0;
}

Ausgabe:

Abs64(-42)        = 42
Sign64(-7)        = -1
Clamp64(150,0,100)= 100
InRange64(50,0,100)= 1
Min3(9,4,7)       = 4
Max3(9,4,7)       = 9
Sqrt64(1000000)   = 1000
Sqrt64(10)        = 3   (floor)
Pow64(2,10)       = 1024
Log2(1024)        = 10
Log2(1000)        = 9     (floor)
Lerp64(100,200,500)      = 150
Map64(512,0,1023,0,100)  = 50

Lerp64 interpoliert in Promille: t = 500 sind 50 %, daher genau die Mitte zwischen 100 und 200. Map64 skaliert einen 10-Bit-Sensorwert (0…1023) auf Prozent.

import std.math;

fn main(): int64 {
    PrintLn("GCD(48,18)          = ", IntToStr(GCD(48, 18)));
    PrintLn("LCM(4,6)            = ", IntToStr(LCM(4, 6)));
    PrintLn("IsPrime(97)         = ", IntToStr(IsPrime(97) as int64));
    PrintLn("NextPrime(90)       = ", IntToStr(NextPrime(90)));
    PrintLn("IsPowerOfTwo(1024)  = ", IntToStr(IsPowerOfTwo(1024) as int64));
    PrintLn("NextPowerOfTwo(1000)= ", IntToStr(NextPowerOfTwo(1000)));
    PrintLn("PopCount(255)       = ", IntToStr(PopCount(255)));

    // Primzahlen bis 30 sammeln
    var n: int64 := 2;
    var zeile: pchar := "Primzahlen < 30:";
    while (n < 30) {
        if (IsPrime(n)) { zeile := StrConcat(zeile, StrConcat(" ", IntToStr(n))); }
        n := n + 1;
    }
    PrintLn(zeile);
    return 0;
}

Ausgabe:

GCD(48,18)          = 6
LCM(4,6)            = 12
IsPrime(97)         = 1
NextPrime(90)       = 97
IsPowerOfTwo(1024)  = 1
NextPowerOfTwo(1000)= 1024
PopCount(255)       = 8
Primzahlen < 30: 2 3 5 7 11 13 17 19 23 29

NextPowerOfTwo ist der übliche Weg, eine Puffergröße auf die nächste Zweierpotenz aufzurunden.

import std.io;
import std.math;

fn zeige(name: pchar, v: f64): void {
    PrintLn(name, " = ", FloatToStr(v, 4));   // zweites Argument: Nachkommastellen
}

fn main(): int64 {
    zeige("SqrtF64(2)   ", SqrtF64(2 as f64));
    zeige("SinF64(1)    ", SinF64(1 as f64));
    zeige("CosF64(0)    ", CosF64(0 as f64));
    zeige("AtanF64(1)   ", AtanF64(1 as f64));
    zeige("Atan2F64(1,1)", Atan2F64(1 as f64, 1 as f64));
    zeige("AcosF64(0)   ", AcosF64(0 as f64));
    zeige("Log2F64(1024)", Log2F64(1024 as f64));
    zeige("ExpF64(1)    ", ExpF64(1 as f64));

    // Runden und Begrenzen
    var x: f64 := fDiv(7 as f64, 2 as f64);          // 3.5
    zeige("FloorF64(3.5)", FloorF64(x));
    zeige("CeilF64(3.5) ", CeilF64(x));
    zeige("RoundF64(3.5)", RoundF64(x));
    zeige("TruncF64(3.5)", TruncF64(x));
    zeige("AbsF64(-3.5) ", AbsF64(fNeg(x)));
    zeige("MinF64(3.5,2)", MinF64(x, 2 as f64));
    return 0;
}

Ausgabe:

SqrtF64(2)    = 1.414213
SinF64(1)     = 0.841470
CosF64(0)     = 1.000000
AtanF64(1)    = 0.785398
Atan2F64(1,1) = 0.785398
AcosF64(0)    = 1.570796
Log2F64(1024) = 10.000000
ExpF64(1)     = 2.718281
FloorF64(3.5) = 3.000000
CeilF64(3.5)  = 4.000000
RoundF64(3.5) = 4.000000
TruncF64(3.5) = 3.000000
AbsF64(-3.5)  = 3.500000
MinF64(3.5,2) = 2.000000

Die Genauigkeit reicht heute bis an die Anzeigegrenze von sechs Nachkommastellen: CosF64(0) liefert 1.000000, SinF64(3) das korrekte 0.141120. Bis Version 1.0.12A rechneten Sinus und Kosinus mit der Näherung π ≈ 355/113 und wichen ab der sechsten Stelle ab — diese Einschränkung gilt nicht mehr.

Gleitkommazahlen entstehen in Lyx über as f64 oder fDiv — ein Literal wie 3.5 gibt es in dieser Form nicht, daher fDiv(7 as f64, 2 as f64).

Alle Angaben mit lyxc 1.0.20F gemessen. Die früher hier verzeichneten Rechenfehler sind behoben (#1444–#1450):

Das ist die wichtigste Umstellung: Sin64, Cos64 und Atan2Microdegrees rechnen in Mikrograd, das Ergebnis der Winkelfunktionen ist mit 1.000.000 skaliert.

Sin64(30000000)   // Sinus von 30°  →  500000  (= 0,5)
Cos64(0)          //                →  1000000 (= 1,0)

Wer versehentlich Grad einsetzt, bekommt kein falsches Ergebnis, sondern praktisch null: Sin64(30) sind 30 Mikrograd, also 0,00003° — der Sinus davon ist auf sechs Stellen 0. Der Fehler fällt damit leicht als „Funktion kaputt“ fehlgedeutet aus.

Die frühere Attrappe Round64(x: int64) ist entfallen (#1450). An ihrer Stelle steht RoundF64(x: f64): f64, das tatsächlich rundet.

Früher fehlte die Argumentreduktion, wodurch ExpF64(5) um 13 % und PowF64(2, 10) um 39 % danebenlagen. Das ist behoben; die verbleibende Abweichung von etwa 1e−6 stammt aus der Festkomma-Näherung von π und e und reicht für alles außer numerisch empfindlichen Rechnungen.

====

Round64(x: int64): int64 gibt x unverändert zurück. Da der Parameter bereits ganzzahlig ist, gibt es nichts zu runden — die Funktion kann nur aus einem abgebrochenen Umbau stammen. Sie sieht am Aufrufort nach einer Rundung aus und tut nichts. Für f64 RoundF64 verwenden.

Die Warnungen früherer Fassungen dieser Seite sind hinfällig. Gegen 1.0.21A einzeln nachgemessen: PopCount(-1) = 64, IsOdd(-3) = 1, Hypot64(3, 4) = 5 und Hypot64(300, 400) = 500, Sin64(45°) = 707107, Cos64(60°) = 500000, Atan2Microdegrees(1, 1) = 45 000 000, und beide Zufallsfunktionen halten über 10 000 Ziehungen ihren Bereich ein.

• Ganzzahl-Grundlagen und Zahlentheorie sind belastbar, einschließlich PopCount und IsOdd bei negativen Argumenten.
• Die Mikrograd-Gruppe ist benutzbar. Zu beachten bleibt allein die Einheit: Winkel gehen in Mikrograd hinein (1° = 1 000 000), Funktionswerte kommen mit Faktor 1 000 000 heraus.
• Pow64 läuft bei großen Werten still über; Argumente vorab gegen Log2 plausibilisieren. Wer den vollen Bereich braucht, nimmt std.i128 oder std.bignum.

• std.math.constants — Präzisionskonstanten (π, e, √2, φ, ln 2 …), Winkelkonvertierungen, ApproxEqual
• std.math_batch — SIMD-beschleunigte Batch-Operationen auf int64-Arrays
• std.vector — 2D/3D-Vektormathematik (baut auf std.math auf)
• std.stats — Mittelwert, Varianz, Standardabweichung