Feedback

C# - Complex <-> String

Veröffentlicht von am 26.06.2013
(0 Bewertungen)
Mithilfe dieser beiden Mothoden kann man eine komplexe Zahl aus einer Zeichenfolge parsen und auch wieder in eine Zeichenfolge umwenadeln.
Die Complex-Struktur liegt im System.Numerics-Namespace, welcher im gleichnahmigen Verweis ab .NET 4.0 liegt.

Die ToStringEx-Methode hat gegenüber der normalen ToString-Methode den Vorteil, das wenn einer der Teile 0 ist, das dieser nicht mit ausgegeben wird. Außerdem wird ein 'i' an den imaginären Teil angehängt. Vorzeichen werden ebenfalls beachttet.

Die ParseComplexNumber-Methode wandelt die Zeichenfolgen analog wieder in eine neue Complex-Instanz um. Auch hier werden Vorzeichen usw. berücksichtigt. Es spielt keine Rolle ob der imaginäre Teil als 1. oder als 2. Teil da steht. Es kann auch nur ein Teil angegeben sein. Einzige vorraussetzung ist, das jeder Teil (Imaginär/Reel) nur höchstens einmal vorkommt.

Die ToStringEx-Methode ist als Erweiterungsmethode für die Complex-Struktur implementiert. Die Parse-Methode muss aus der Extensions-Klasse aufgerufen werden.
Snippet in VB übersetzen
    static class Extensions
    {
        /// <summary>
        /// Konvertiert eine Zeichenfolge in eine Komplexe Zahl. Dabei muss die Zeichenfolge folgenden Aufbau haben: "[+|-|]R[+|-]Ii". Reeller und Imaginärer Anteil können vertauscht werden. Es kann auch nur ein Teil angegeben werden. Der Imaginäre Anteil  wird durch ein kleines i gekennzeichnet.
        /// </summary>
        /// <param name="num">Die Zeichenfolge.</param>
        /// <returns>Die komplexe Zahl, welche aus der Zeichenfolge geparsed wurde.</returns>
        public static Complex ParseComplexNumber(string num)
        {
            string[] s = num.Split(new char[] { '-', '+' }, StringSplitOptions.RemoveEmptyEntries);
            if (s.Length == 1)
            {
                if (s[0].Contains('i'))
                    return new Complex(0, num.StartsWith("-") ? -double.Parse(s[0].TrimEnd('i')) : double.Parse(s[0].TrimEnd('i')));
                else
                    return new Complex(num.StartsWith("-") ? -double.Parse(s[0].TrimEnd('i')) : double.Parse(s[0].TrimEnd('i')), 0);
            }
            else
            {
                double a = 0, b = 0;
                a = double.Parse(s[0].TrimEnd('i'));
                b = double.Parse(s[1].TrimEnd('i'));
                if (num.StartsWith("-"))
                    a *= -1;
                if (num.TrimStart('-').Contains('-'))
                    b *= -1;

                if (s[0].Contains('i'))
                    return new Complex(b, a);
                else
                    return new Complex(a, b);
            }
        }

        /// <summary>
        /// Diese Methode gibt den Wert der Komplexen Zahl (R+I) in mathematisch korrekter Schreibweise zurück.
        /// </summary>
        /// <param name="c">Die zu konvertierende, komplxe Zahl.</param>
        /// <returns>Eine Zeichenfolge, welche die komplexe Zahl repräsentiert.</returns>
        public static string ToStringEx(this Complex c)
        {
            if (c.Imaginary == 0)
                return c.Real.ToString();
            else if (c.Real == 0)
                return string.Format("{0}i", c.Imaginary);
            else
                return string.Format("{0}{1}i", c.Real, c.Imaginary < 0 ? c.Imaginary.ToString() : "+" + c.Imaginary.ToString());
        }
    }

2 Kommentare zum Snippet

Scavanger schrieb am 01.07.2013:
Nett!

Die ComplexToString() wäre als Erweiterungsmethode eine schöne Sache.

Auch eine TryParseComplexNumber() wäre nicht verkehrt.
Koopakiller schrieb am 01.07.2013:
Danke :)
Die ToStringEx-Methode habe ich zu einer Erweiterungsmethode ergänzt. Für die Parse-Methode ist es leider nicht möglich bzw. wenig sinnvoll, da man sowieso eine neue Instanz der Complex-Struktur erstellen muss.
 

Logge dich ein, um hier zu kommentieren!