Click here to Skip to main content
12,758,605 members (34,764 online)
Click here to Skip to main content

Stats

30.7K views
171 downloads
51 bookmarked
Posted 7 Jan 2008

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

, 7 Jan 2008 CPOL
Further studies of Parallel FX.
/* 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
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Marc Clifton
United States United States
Marc is the creator of two open source projects, MyXaml, a declarative (XML) instantiation engine and the Advanced Unit Testing framework, and Interacx, a commercial n-tier RAD application suite.  Visit his website, www.marcclifton.com, where you will find many of his articles and his blog.

Marc lives in Philmont, NY.

You may also be interested in...

Permalink | Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.170217.1 | Last Updated 7 Jan 2008
Article Copyright 2008 by Marc Clifton
Everything else Copyright © CodeProject, 1999-2017
Layout: fixed | fluid