//******************************************************************************************************//  ComplexNumber.cs - Gbtc////  Copyright © 2016, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may//  not use this file except in compliance with the License. You may obtain a copy of the License at:////      http://opensource.org/licenses/MIT////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  04/14/2016 - Stephen C. Wills//       Generated original version of source code.////****************************************************************************************************** using System;using System.Data.SqlTypes;using System.Text;using System.Text.RegularExpressions;using Microsoft.SqlServer.Server; namespace GSF.Core.SqlClr{    /// <summary>    /// Defines a complex number type that can be used in a SQL Server database.    /// </summary>    [Serializable]    [SqlUserDefinedType(Format.Native, IsByteOrdered = true)]    public struct ComplexNumber : INullable    {        #region [ Members ]         // Fields        private bool m_isNull;        private double m_real;        private double m_imaginary;         #endregion         #region [ Properties ]         /// <summary>        /// Gets a value that indicates whether the complex number is null.        /// </summary>        public bool IsNull        {            get            {                return m_isNull;            }        }         /// <summary>        /// Gets or sets the real component of a complex number.        /// </summary>        /// <remarks>        /// Usage example:        ///         /// <code>        /// DECLARE @tbl TABLE(Num COMPLEX)        /// INSERT INTO @tbl VALUES('1+5i')        /// UPDATE @tbl SET Num.Real = 5        /// SELECT Num.ToString(), Num.Real FROM @tbl        /// -- Returns [Num: 5+5i, Real: 5]        /// </code>        /// </remarks>        public double Real        {            get            {                return m_real;            }            set            {                m_real = value;            }        }         /// <summary>        /// Gets or sets the imaginary component of a complex number.        /// </summary>        /// <remarks>        /// Usage example:        ///         /// <code>        /// DECLARE @tbl TABLE(Num COMPLEX)        /// INSERT INTO @tbl VALUES('1+5i')        /// UPDATE @tbl SET Num.Imaginary = 1        /// SELECT Num.ToString(), Num.Imaginary FROM @tbl        /// -- Returns [Num: 1+1i, Imaginary: 1]        /// </code>        /// </remarks>        public double Imaginary        {            get            {                return m_imaginary;            }            set            {                m_imaginary = value;            }        }         /// <summary>        /// Gets or sets the magnitude of a complex number.        /// </summary>        /// <remarks>        /// Usage example:        ///         /// <code>        /// DECLARE @tbl TABLE(Num COMPLEX)        /// INSERT INTO @tbl VALUES('1+5i')        /// UPDATE @tbl SET Num.Magnitude = 5        /// SELECT Num.ToString(), Num.Magnitude FROM @tbl        /// -- Returns [Num: 0.98058+4.9029i, Magnitude: 5]        /// </code>        /// </remarks>        public double Magnitude        {            get            {                return Math.Sqrt(m_real * m_real + m_imaginary * m_imaginary);            }            set            {                double angle = Angle;                m_real = value * Math.Cos(angle);                m_imaginary = value * Math.Sin(angle);            }        }         /// <summary>        /// Gets or sets the angle of a complex number.        /// </summary>        /// <remarks>        /// Usage example:        ///         /// <code>        /// DECLARE @tbl TABLE(Num COMPLEX)        /// INSERT INTO @tbl VALUES('1+5i')        /// UPDATE @tbl SET Num.Angle = 1        /// SELECT Num.ToString(), Num.Angle FROM @tbl        /// -- Returns [Num: 2.75501+4.29068i, Angle: 1]        /// </code>        /// </remarks>        public double Angle        {            get            {                return Math.Atan2(m_imaginary, m_real);            }            set            {                double magnitude = Magnitude;                m_real = magnitude * Math.Cos(value);                m_imaginary = magnitude * Math.Sin(value);            }        }         #endregion         #region [ Methods ]         /// <summary>        /// Returns the complex conjugate of a complex number.        /// </summary>        /// <returns>The complex conjugate.</returns>        /// <remarks>        /// Usage example:        ///         /// <code>        /// DECLARE @complex COMPLEX = '1+5i'        /// SELECT @complex.Conjugate().ToString()        /// -- Returns 1-5i        /// </code>        /// </remarks>        [SqlMethod(OnNullCall = false, IsDeterministic = true)]        public ComplexNumber Conjugate()        {            ComplexNumber num = new ComplexNumber();            num.m_real = m_real;            num.m_imaginary = -m_imaginary;            return num;        }         /// <summary>        /// Returns the negative value of the complex number.        /// </summary>        /// <returns>The negative value.</returns>        /// <remarks>        /// Usage example:        ///         /// <code>        /// DECLARE @complex COMPLEX = '1+5i'        /// SELECT @complex.Negate().ToString()        /// -- Returns -1-5i        /// </code>        /// </remarks>        [SqlMethod(OnNullCall = false, IsDeterministic = true)]        public ComplexNumber Negate()        {            ComplexNumber num = new ComplexNumber();            num.m_real = -m_real;            num.m_imaginary = -m_imaginary;            return num;        }         /// <summary>        /// Returns the sum of two complex numbers.        /// </summary>        /// <param name="num">The number to be added to this one.</param>        /// <returns>The sum.</returns>        /// <remarks>        /// Usage example:        ///         /// <code>        /// DECLARE @complex COMPLEX = '1+5i'        /// SELECT @complex.[Add]('-5+1i').ToString()        /// -- Returns -4+6i        /// </code>        /// </remarks>        [SqlMethod(OnNullCall = false, IsDeterministic = true)]        public ComplexNumber Add(ComplexNumber num)        {            ComplexNumber result = new ComplexNumber();            result.m_real = m_real + num.m_real;            result.m_imaginary = m_imaginary + num.m_imaginary;            return result;        }         /// <summary>        /// Returns the difference of two complex numbers.        /// </summary>        /// <param name="num">The number to be subtracted from this one.</param>        /// <returns>The difference.</returns>        /// <remarks>        /// Usage example:        ///         /// <code>        /// DECLARE @complex COMPLEX = '1+5i'        /// SELECT @complex.Subtract('-5+1i').ToString()        /// -- Returns 6+4i        /// </code>        /// </remarks>        [SqlMethod(OnNullCall = false, IsDeterministic = true)]        public ComplexNumber Subtract(ComplexNumber num)        {            ComplexNumber result = new ComplexNumber();            result.m_real = m_real - num.m_real;            result.m_imaginary = m_imaginary - num.m_imaginary;            return result;        }         /// <summary>        /// Returns the product of two complex numbers.        /// </summary>        /// <param name="num">The number to be multiplied with this one.</param>        /// <returns>The product.</returns>        /// <remarks>        /// Usage example:        ///         /// <code>        /// DECLARE @complex COMPLEX = '1+5i'        /// SELECT @complex.Multiply('-5+1i').ToString()        /// -- Returns -10-24i        /// </code>        /// </remarks>        [SqlMethod(OnNullCall = false, IsDeterministic = true)]        public ComplexNumber Multiply(ComplexNumber num)        {            ComplexNumber result = new ComplexNumber();            result.SetPhasor(Magnitude * num.Magnitude, Angle + num.Angle);            return result;        }         /// <summary>        /// Returns the quotient of two complex numbers.        /// </summary>        /// <param name="num">The number to divide by this one.</param>        /// <returns>The quotient.</returns>        /// <remarks>        /// Usage example:        ///         /// <code>        /// DECLARE @complex COMPLEX = '1+5i'        /// SELECT @complex.Divide('-5+1i').ToString()        /// -- Returns -1i        /// </code>        /// </remarks>        [SqlMethod(OnNullCall = false, IsDeterministic = true)]        public ComplexNumber Divide(ComplexNumber num)        {            ComplexNumber result = new ComplexNumber();            result.SetPhasor(Magnitude / num.Magnitude, Angle - num.Angle);            return result;        }         /// <summary>        /// Sets the real and imaginary components of the complex number.        /// </summary>        /// <param name="real">The real component.</param>        /// <param name="imaginary">The imaginary component.</param>        /// <remarks>        /// Usage example:        ///         /// <code>        /// DECLARE @tbl TABLE(Num COMPLEX)        /// INSERT INTO @tbl VALUES('1+5i')        /// UPDATE @tbl SET Num.SetRect(-5, 1)        /// SELECT Num.ToString() FROM @tbl        /// -- Returns -5+1i        /// </code>        /// </remarks>        [SqlMethod(IsMutator = true, OnNullCall = false)]        public void SetRect(double real, double imaginary)        {            m_real = real;            m_imaginary = imaginary;        }         /// <summary>        /// Sets the magnitude and angle of the vector described by a complex number.        /// </summary>        /// <param name="magnitude">The magnitude.</param>        /// <param name="angle">The angle.</param>        /// <remarks>        /// Usage example:        ///         /// <code>        /// DECLARE @tbl TABLE(Num COMPLEX)        /// INSERT INTO @tbl VALUES('1+5i')        /// UPDATE @tbl SET Num.SetPhasor(-5, 1)        /// SELECT Num.ToString() FROM @tbl        /// -- Returns -2.70151-4.20735i        /// </code>        /// </remarks>        [SqlMethod(IsMutator = true, OnNullCall = false)]        public void SetPhasor(double magnitude, double angle)        {            m_real = magnitude * Math.Cos(angle);            m_imaginary = magnitude * Math.Sin(angle);        }         /// <summary>        /// Returns the string representation of a complex number.        /// </summary>        /// <returns>The string representation of the complex number.</returns>        public override string ToString()        {            StringBuilder image = new StringBuilder();            double real = Math.Round(m_real, 5);            double imaginary = Math.Round(m_imaginary, 5);             if (real == 0.0D && imaginary == 0.0D)                return "0";             if (real != 0.0D)                image.Append(real);             if (imaginary != 0.0D)            {                image.Append(imaginary > 0.0D ? "+" : "-");                image.Append(Math.Abs(imaginary));                image.Append('i');            }             return image.ToString();        }         #endregion         #region [ Static ]         // Static Properties         /// <summary>        /// Gets a value that represents a null complex number.        /// </summary>        public static ComplexNumber Null        {            get            {                ComplexNumber num = new ComplexNumber();                num.m_isNull = true;                return num;            }        }         // Static Methods         /// <summary>        /// Converts the string representation of a complex number to a complex number.        /// </summary>        /// <param name="str">The string representation of a complex number.</param>        /// <returns>The complex number.</returns>        [SqlMethod(OnNullCall = false)]        public static ComplexNumber Parse(SqlString str)        {            // Regex pattern to match a single number            const string NumberPattern = @"(?<Number>[+-]?(?:[ij][0-9eE\.]+|[0-9eE\.]+[ij]?))";             // Regex pattern to match the operator            const string OperatorPattern = @"(?<Operator>[+-])";             // Regex pattern to match the whole complex number            //            const string Pattern = @"^" +               // Start of string                                   @"\s*" +             // Whitespace                                   NumberPattern +      // Number                                   @"\s*" +             // Whitespace                                   "(?:" +              // Start of optional of noncapturing group                                   OperatorPattern +    // Operator                                   @"\s*" +             // Whitespace                                   NumberPattern +      // Number                                   @"\s*" +             // Whitespace                                   ")?" +               // End of optional noncapturing group                                   "$";                 // End of string             Match match;            CaptureCollection numberCaptures;            CaptureCollection operatorCaptures;             double op = 1.0;            double real = 0.0D;            double imaginary = 0.0D;             // Parses the string as a double by first removing the i or j            Func<string, double> parse = s => double.Parse(Regex.Replace(s, "[ij]", ""));            Func<string, bool> isImaginary = s => Regex.IsMatch(s, "[ij]");             ComplexNumber num;             if (str.IsNull)                return Null;             match = Regex.Match(str.Value, Pattern);             // String format is invalid if regex does not match            if (!match.Success)                throw new FormatException("Input string was not in a correct format.");             // Get the captures for the Number and Operator groups            numberCaptures = match.Groups["Number"].Captures;            operatorCaptures = match.Groups["Operator"].Captures;             // If the string defines two numbers, ensure that exactly one of them is imaginary            if (numberCaptures.Count == 2 && !(isImaginary(numberCaptures[0].Value) ^ isImaginary(numberCaptures[1].Value)))                throw new FormatException("Input string was not in a correct format.");             // Parse the first capture group to the            // appropriate part of the complex number            if (isImaginary(numberCaptures[0].Value))                imaginary = parse(numberCaptures[0].Value);            else                real = parse(numberCaptures[0].Value);             if (numberCaptures.Count == 2)            {                // Determine if the sign needs to be                // inverted based on the operator                if (operatorCaptures[0].Value == "-")                    op = -1.0;                 // Parse the second capture group to the                // appropriate part of the complex number                if (isImaginary(numberCaptures[1].Value))                    imaginary = op * parse(numberCaptures[1].Value);                else                    real = op * parse(numberCaptures[1].Value);            }             // Return the complex number            num = new ComplexNumber();            num.m_real = real;            num.m_imaginary = imaginary;            return num;        }         #endregion    }}