Concurrent Programming - Investigating Task Messaging To Achieve Synchronization Free Inter-Task Communication

/* Copyright (c) 2006-2007 Coskun Oba
 * *****************************************************************************
 *  
 * SCI - Scientific Software Platform
 * Copyright (c) 2006-2007
 * All rights reserved.
 * 
 * Coskun Oba
 * oba.coskun@hotmail.com
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY COSKUN OBA ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL COSKUN OBA BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * *****************************************************************************/

using System;
using System.Collections.Generic;
using System.Text;

namespace Sci.Math
{
    #region ComplexNumber
    /// <summary>
    /// Represents a complex number. 
    /// A complex number is a scalar of the form z = x + iy 
    /// where x and y are real numbers, and i is the imaginary unit, 
    /// with the property i*i = -1.
    /// </summary>
    public struct ComplexNumber
    {
        /// <summary>
        /// The real component of complex number z.
        /// </summary>
        private double real;
        /// <summary>
        /// The imaginary component of complex number z.
        /// </summary>
        private double imaginary;

        /// <summary>
        /// Constructs a complex number from the given value. 
        /// Imaginary component(y)is zero.
        /// </summary>
        /// <param name="real">The real component of the complex number.</param>
        public ComplexNumber(double real)
        {
            this.real = real;
            this.imaginary = 0;
        }

        /// <summary>
        /// Constructs a complex number from the given values. 
        /// </summary>
        /// <param name="real">The real component of the complex number.</param>
        /// <param name="imaginary">The imaginary component of the complex number.</param>
        public ComplexNumber(double real, double imaginary)
        {
            this.real = real;
            this.imaginary = imaginary;
        }

        /// <summary>
        /// Copy constructor.
        /// Constructs a complex number from the given complex number.
        /// </summary>
        /// <param name="z">Complex number to be copied.</param>
        public ComplexNumber(ComplexNumber z)
        {
            this.real = z.real;
            this.imaginary = z.imaginary;
        }

        #region Properties
        /// <summary>
        /// Gets/Sets the real component of the complex number.
        /// </summary>
        public double Re
        {
            get { return this.real; }
            set { this.real = value; }
        }

        /// <summary>
        /// Gets/Sets the imaginary component of the complex number.
        /// </summary>
        public double Im
        {
            get { return this.imaginary; }
            set { this.imaginary = value; }
        }

        /// <summary>
        /// Gets the modulus.
        /// The modulus is the positive real scalar which measures the distance from the origin.
        /// </summary>
        public double Modulus
        {
            get { return System.Math.Sqrt(real * real + imaginary * imaginary); }
        }

        /// <summary>
        /// Gets the Argument.
        /// The argument measures the angle that the line from the origin to the 
        /// point z makes with the real axis. It is measured in an 
        /// anticlockwise direction.
        /// The argument is returned in radians.
        /// </summary>
        public double Argument
        {
            get { return System.Math.Atan2(imaginary , real); }
        }
        #endregion

        #region Operator Overloading
        /// <summary>
        /// Represents the implicit coversion of a scalar to a complex number.
        /// </summary>
        /// <param name="scalar">A double precision number to be converted.</param>
        /// <returns>Returns a ComplexNumber.</returns>
        public static implicit operator ComplexNumber(double scalar)
        {
            return new ComplexNumber(scalar);
        }

        /// <summary>
        /// Equality operator.
        /// Checks the equality of two given complex numbers.
        /// </summary>
        /// <param name="rhs">ComplexNumber on the Right-Hand Side of the equality operator.</param>
        /// <param name="lhs">ComplexNumber on the Left-Hand Side of the equality operator.</param>
        /// <returns>Returns true if the given complex numbers are equal, false otherwise.</returns>
        public static bool operator ==(ComplexNumber rhs, ComplexNumber lhs)
        {
            return (rhs.real.Equals(lhs.real) && rhs.imaginary.Equals(lhs.imaginary));
        }

        /// <summary>
        /// Inequality operator.
        /// Checks the inequality of two given complex numbers.
        /// </summary>
        /// <param name="rhs">ComplexNumber on the Right-Hand Side of the equality operator.</param>
        /// <param name="lhs">ComplexNumber on the Left-Hand Side of the equality operator.</param>
        /// <returns>Returns true if the given complex numbers are not equal, false otherwise.</returns>
        public static bool operator !=(ComplexNumber rhs, ComplexNumber lhs)
        {
            return !(rhs == lhs);
        }

        /// <summary>
        /// Unary negation operator.
        /// Negates the given complex number.
        /// </summary>
        /// <param name="z">Complex number to be negated.</param>
        /// <returns>
        /// Returns a complex number which is the negative equavalent of the given
        /// complex number.
        /// </returns>
        public static ComplexNumber operator -(ComplexNumber z)
        {
            return new ComplexNumber(-z.real, -z.imaginary);
        }

        /// <summary>
        /// Binary plus operator.
        /// </summary>
        /// <param name="op1">First operand.</param>
        /// <param name="op2">Second operand.</param>
        /// <returns>Returns a complex number which represents the z = op1 + op2 operation.</returns>
        public static ComplexNumber operator +(ComplexNumber op1, ComplexNumber op2)
        {
            return new ComplexNumber(op1.real + op2.real, op1.imaginary + op2.imaginary);
        }

        /// <summary>
        /// Binary minus operator.
        /// </summary>
        /// <param name="op1">First operand.</param>
        /// <param name="op2">Second operand.</param>
        /// <returns>Returns a complex number which represents the z = op1 - op2 operation.</returns>
        public static ComplexNumber operator -(ComplexNumber op1, ComplexNumber op2)
        {
            return op1 + (-op2);
        }

        /// <summary>
        /// Binary multiplication operator.
        /// </summary>
        /// <param name="op1">First operand.</param>
        /// <param name="op2">Second operand.</param>
        /// <returns>Returns a complex number which represents the z = op1 * op2 operation.</returns>
        public static ComplexNumber operator *(ComplexNumber op1, ComplexNumber op2)
        {
            double real = op1.real * op2.real - op1.imaginary * op2.imaginary;
            double imaginary = op1.imaginary * op2.real + op1.real * op2.imaginary;
            
            return new ComplexNumber(real, imaginary);
        }

        /// <summary>
        /// Binary division operator.
        /// </summary>
        /// <param name="op1">First operand.</param>
        /// <param name="op2">Second operand.</param>
        /// <returns>Returns a complex number which represents the z = op1 / op2 operation.</returns>
        public static ComplexNumber operator /(ComplexNumber op1, ComplexNumber op2)
        {
            double denominator = System.Math.Pow(op2.real, 2) + System.Math.Pow(op2.imaginary, 2);
            double real = (op1.real * op2.real + op1.imaginary * op2.imaginary) / denominator;
            double imaginary = (op1.imaginary* op2.real - op1.real*op2.imaginary) / denominator;
            
            return new ComplexNumber(real, imaginary);
        }
        #endregion

        #region Overriden Methods
        /// <summary>
        /// Checks whether the given object is equal to this complex number.
        /// </summary>
        /// <param name="obj">Object to be checked if it is equal to this complex number.</param>
        /// <returns>Returns true if the given object is equal to this complex number, false otherwise.</returns>
        public override bool Equals(object obj)
        {
            return ((obj is ComplexNumber)) ? this == (ComplexNumber)obj : false;
        }

        /// <summary>
        /// Hashcode that reprsents this complex number.
        /// </summary>
        /// <returns>Returns integer value of the hashcode.</returns>
        public override int GetHashCode()
        {
            return real.GetHashCode() ^ imaginary.GetHashCode();
        }

        /// <summary>
        /// String representation of this complex number.
        /// </summary>
        /// <returns>Returns the string representation of this complex number.</returns>
        public override string ToString()
        {
            StringBuilder z = new StringBuilder();
            z.Append("(" + real.ToString());

            if (imaginary > 0)
                z.Append(" + ");
            else if (imaginary < 0)
                z.Append(" - ");

            z.Append(System.Math.Abs(imaginary).ToString());
            z.Append("i)");

            return z.ToString();
        }
        #endregion
    }
    #endregion
}