Schlagwort: Theorie

Benchmarking unter C# 👍 👎

Teilweise ist zu sehen, dass Entwickler unter C# Benchmarks mit Hilfe der DateTime-Struktur umsetzen. Diese ist für derartige Zwecke jedoch zu ungenau und es sollte stattdessen mit der etwas spezielleren Stopwatch-Klasse gearbeitet werden. Wie genau das nun aussehen kann, möchte ich gerne mit diesem Beitrag kurz aufzeigen:
Benchmark per Stopwatch durchführen
01020304050607080910
Stopwatch stopwatch = Stopwatch.StartNew();{      // Simulation einer längeren Ausführungszeit    for(int i = 0; i < 5; i++) {        Thread.Sleep(50);    }}stopwatch.Stop();
long elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
Darüber hinaus ist für besonders präzise Messungen insbesondere die ElapsedTicks-Eigenschaft interessant.

Selbstverständlich benötigt ein umfassendes Benchmarking einer Anwendung etwas mehr Komfort als eine schnelle Messung, es bietet sich daher beispielsweise auch eine entsprechende Suche im NuGet-Verzeichnis an.

Grad-Angaben für trigonometrische Funktionen in C# 👍 👎

In einem Gespräch wurde mir kürzlich vom "seltsamen" Verhalten trigonometrischer Methoden wie Math.Sin oder Math.Cos berichtet. Nun lag das Problem jedoch weniger an C# (ohnehin kaum vorstellbar Smiley: winking), sondern vielmehr an den übergebenen Werten – diese lagen nämlich in Grad vor, wobei C# das Bogenmaß erwartet.

Glücklicherweise lassen sich die Werte jedoch schnell und problemlos jeweils zueinander umrechnen:
Umrechung von Grad <-> Bogenmaß
010203040506070809
  // Grad zu Bogenmaß umrechnenpublic static double DegToRad(double degrees) {    return (degrees * (Math.PI / 180));}
// Bogenmaß zu Grad umrechnenpublic static double RadToDeg(double radians) { return (radians * (180 / Math.PI));}
Entsprechende Funktionen habe ich im Rahmen von "PHP-Funktionen in C#" schon einmal zur Verfügung gestellt:

Parität einer Zahl prüfen 👍 👎

Manchmal kann es für ein Problem relevant sein, ob eine Zahl (un-)gerade ist. Dies lässt sich sehr einfach durch Verwendung der ganzzahligen Division mit Rest (Modulo) bewerkstelligen – wir dividieren dabei einfach durch 2.

Eine Erweiterungsmethode für den Typ int in C# könnte beispielsweise wie folgt aussehen:
int.IsEven implementieren und verwenden (Modulo)
0102030405
public static bool IsEven(this int number) {    return ((number % 2) == 0);}
bool isEven = (7).IsEven(); // false
Im Stellenwertsystem zur Basis 2 (Dualsystem) kann man sich zu Nutze machen, dass bei ungeraden Zahlen die letzte Ziffer mit der Wertigkeit 1 gesetzt sein muss, da ansonsten die Zahl in jedem Fall gerade wäre. Übertragen auf die Arbeit im Binärsystem soll also das letzte Bit [nicht] gesetzt sein, was wir durch eine bitweise Verknüpfung ermitteln und dadurch eine entsprechende Optimierung ermöglichen:
int.IsEven implementieren und verwenden (Bitarithmetik)
0102030405
public static bool IsEven(this int number) {    return ((number & 1) == 0);}
bool isEven = (7).IsEven(); // false
Entsprechende IsOdd()-Methoden können ggf. analog dazu implementiert werden.

Langzahlarithmetik in C# 👍 👎

Für manche Anwendungen kann es notwendig werden, mit ganzen Zahlen zu arbeiten, die mitunter deutlich größer (bzw. kleiner) sind, als die CLS-Typen Int16 (short), Int32 (int) und Int64 (long) definieren.

Zwar ist es eine gute Übung, arithmetische Operationen auf ganzen Zahlen, die als Zeichenkette vorliegen, selbst zu implementieren – das .NET-Framework bringt jedoch bereits seit v4.0 die Struktur BigInteger aus System.Numerics mit. Sofern du dir also nicht sehr sicher bist, eine für deinen spezifischen Anwendungsfall bessere Implementierung vorliegen zu haben, solltest du eher auf das Framework setzen.

Die Verwendung gestaltet sich denkbar einfach, insofern belasse ich es für den Moment bei ein paar Beispielen:
BigInteger verwenden
0102030405060708091011
BigInteger a = BigInteger.Parse("34872923458349238592320478");BigInteger b = BigInteger.Parse("14782398471853465710237672");
// Operatorüberladung für BigInteger.Add(a, b)BigInteger sum = (a + b); // 49655321930202704302558150
// Operatorüberladung für BigInteger.Subtract(a, b)BigInteger difference = (a – b); // 20090524986495772882082806
// Operatorüberladung für BigInteger.Multiply(a, b)BigInteger product = (a * b); // 515505450439764661138576432136536115538523372647216
Selbstverständlich stehen noch einige andere nützliche Operationen und Indikatoren zur Verfügung.

Notwendig sind derartige Vorgehensweisen beispielsweise in der Kryptologie oder bei Simulationen in der numerischen Mathematik. Hauptsächlich kam ich jedoch deswegen auf diesen kurzen Beitrag, da einige Entwickler die Einführung dieser Struktur (BigInteger ist nicht als Klasse implementiert) verpasst zu haben scheinen. Smiley: smiling

Zahl auf Zweierpotenz prüfen 👍 👎

Für manche Algorithmen bestehen Optimierungsansätze, wenn eine zu untersuchende Zahl eine Zweierpotenz ist. Daher möchte ich mit diesem Beitrag aufzeigen, wie sich diese Problemstellung möglichst effizient lösen lässt.

Naive Ansätze arbeiten mit Schleifen und prüfen schrittweise alle in Frage kommenden Zweierpotenzen – es ist leicht einzusehen, dass dieses Vorgehen insbesondere für größere Zahlen eher mäßig effizient ist. Alternativ könnte man auf die Idee kommen, das Problem mit Logarithmen zu lösen – hier kann es jedoch zu Rundungsproblemen kommen. Wir sollten uns daher die Struktur entsprechender Zahlen einmal genauer ansehen:
Zweierpotenzen
010203040506
                  Dualzahl     Dezimalzahl--------------------------------------------       20               1            1       21              10            2       22             100            4       23            1000            8
Offensichtlich ist bei einer Zweierpotenz 2n demnach das (n + 1)-te Bit auf 1 gesetzt und alle ggf. nachfolgenden Stellen besitzen den Wert 0 – was kaum eine Überraschung darstellen sollte. Wir müssen nun jedoch nicht jedes Bit einzeln prüfen, ob die Zahl auf dieses "Muster" passt, sondern können uns das Bitmuster der Zahl 2n – 1 zu Nutze machen:
Voränger von Zweierpotenzen
010203040506
                  Dualzahl     2n – 1 (dual)--------------------------------------------       20               1            0       21              10           01       22             100          011       23            1000         0111
Wie selbstverständlich zu erwarten war, muss der Vorgänger ein inverses Bitmuster besitzen. Dies hilft uns insofern weiter, als dass wir diese beiden Zahlen mit einem bitweisen UND verknüpfen und auf Gleichheit mit 0 prüfen können, was bei Zweierpotenzen zutreffen muss.

In C# könnte die Implementierung beispielsweise wie folgt aussehen:
Zahl auf Zweierpotenz prüfen (Basis)
010203
public static bool IsPowerOfTwo(uint number) {    return ((number & (number – 1)) == 0);}
Dieses Vorgehen liefert jedoch auch für die Zahl 0 den Wert true zurück. Wir prüfen diesen Fall daher separat:
Zahl auf Zweierpotenz prüfen (Erweiterung)
01020304050607
public static bool IsPowerOfTwo(uint number) {    return (        (number != 0)          &&        ((number & (number – 1)) == 0)    );}

123

Projektverweise

Kategorien / Archiv  |  Übersicht RSS-Feed

Schlagworte

Suche