Click here to Skip to main content
Click here to Skip to main content
Add your own
alternative version

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

, 7 Jan 2008 CPOL
Further studies of Parallel FX.
mandelbrot2.zip
Mandelbrot2
demo
ms
Ms
bin
Release
ms.vshost.exe
ms.vshost.exe.manifest
Clifton.Concurrent
Clifton.Tools.Data
Ms.csproj.user
Properties
Settings.settings
sci.math
doc
obj
Debug
ResolveAssemblyReference.cache
Release
ResolveAssemblyReference.cache
Properties
sci
doc
Properties
/* 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 Fraction
    /// <summary>
    /// Represents the fractional numbers. 
    /// A fraction is a quotient of numbers, representing the quantity obtained 
    /// when the numerator is divided by the denominator.
    /// </summary>
    public struct Fraction
    {
        /// <summary>
        /// Represents the numerator of the fractional scalar.
        /// </summary>
        private int numerator;

        /// <summary>
        /// Represents the denominator of the fractional scalar.
        /// </summary>
        private int denominator;

        /// <summary>
        /// Constructs a Fraction from the given value. 
        /// The numerator of the fraction is equal to the given value, and the denominator = 1.
        /// </summary>
        /// <param name="number">Numerator.</param>
        public Fraction(int number)
        {
            this.numerator = number;
            this.denominator = 1;
            ReduceFraction(ref this);
        }

        /// <summary>
        /// Constructs a Fraction from the given values.
        /// </summary>
        /// <param name="numerator">Numerator.</param>
        /// <param name="denominator">Denominator.</param>
        public Fraction(int numerator, int denominator)
        {
            this.numerator = numerator;
            this.denominator = denominator;

            if (denominator < 0)
            {
                this.numerator = -numerator;
                this.denominator = -denominator;
            }
            ReduceFraction(ref this);
        }

        #region Properties
        /// <summary>
        /// Gets/Sets the numerator.
        /// </summary>
        public int Numerator
        {
            get { return numerator; }
            set { numerator = value; }
        }

        /// <summary>
        /// Gets/Sets the denominator.
        /// </summary>
        public int Denominator
        {
            get { return denominator; }
            set 
            {
                denominator = value;
                if (denominator < 0)
                {
                    numerator = -numerator;
                    denominator = -denominator;
                }
            }
        }
        #endregion

        #region Special Values
        /// <summary>
        /// Represents the scalar zero (0) as a Fraction.
        /// </summary>
        public static readonly Fraction Zero = new Fraction(0, 1);
        #endregion

        #region Static Methods
        /// <summary>
        /// Returns the inverse of the given fraction.
        /// </summary>
        /// <param name="f">Fraction.</param>
        /// <returns>Returns the inverse of the given fraction.</returns>
        public static Fraction Inverse(Fraction f)
        {
            return new Fraction(f.denominator, f.numerator);
        }

        /// <summary>
        /// Reduces the given fraction using 
        /// the greatest common divisor of the numerator and the denominator.
        /// </summary>
        /// <param name="f">Fraction to be reduced.</param>
        public static void ReduceFraction(ref Fraction f)
        {
            int gcd = Sci.Math.Function.GCD(f.numerator, f.denominator);
            f.numerator /= gcd;
            f.denominator /= gcd;
        }
        #endregion

        #region Operator Overloading
        /// <summary>
        /// Represents the implicit coversion of an integer value to a Fraction.
        /// </summary>
        /// <param name="number">An integer scalar to be converted.</param>
        /// <returns>Returns a Fraction.</returns>
        public static implicit operator Fraction(int number)
        {
            return new Fraction(number, 1);
        }

        /// <summary>
        /// Equality operator.
        /// Checks the equality of two given Fractions.
        /// </summary>
        /// <param name="rhs">Fraction on the Right-Hand Side of the equality operator.</param>
        /// <param name="lhs">Fraction on the Left-Hand Side of the equality operator.</param>
        /// <returns>Returns true if the given Fractions are equal, false otherwise.</returns>
        public static bool operator ==(Fraction rhs, Fraction lhs)
        {
            int left = rhs.numerator * lhs.denominator;
            int right = rhs.denominator * lhs.numerator;

            return (left.Equals(right));
        }

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

        /// <summary>
        /// Unary negation operator.
        /// Negates the given Fraction.
        /// </summary>
        /// <param name="f">Fraction to be negated.</param>
        /// <returns>
        /// Returns a Fraction which is the negative equavalent of the given Fraction.
        /// </returns>
        public static Fraction operator -(Fraction f)
        {
            return new Fraction(-f.numerator, f.denominator);
        }

        /// <summary>
        /// Binary plus operator.
        /// </summary>
        /// <param name="op1">First operand.</param>
        /// <param name="op2">Second operand.</param>
        /// <returns>Returns a Fraction which represents the f = op1 + op2 operation.</returns>
        public static Fraction operator +(Fraction op1, Fraction op2)
        {
            if (op1.denominator.Equals(op2.denominator))
            {
                return new Fraction(op1.numerator + op2.numerator, op1.denominator);
            }

            int numerator = op1.numerator * op2.denominator +
                                op1.denominator * op2.numerator;
            int denominator = op1.denominator * op2.denominator;

            return new Fraction(numerator, denominator);
        }

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

        /// <summary>
        /// Binary multiplication operator.
        /// </summary>
        /// <param name="op1">First operand.</param>
        /// <param name="op2">Second operand.</param>
        /// <returns>Returns a Fraction which represents the f = op1 * op2 operation.</returns>
        public static Fraction operator *(Fraction op1, Fraction op2)
        {
            int numerator = op1.numerator * op2.numerator;
            int denominator = op1.denominator * op2.denominator;

            return new Fraction(numerator, denominator);
        }

        /// <summary>
        /// Binary division operator.
        /// </summary>
        /// <param name="op1">First operand.</param>
        /// <param name="op2">Second operand.</param>
        /// <returns>Returns a Fraction which represents the f = op1 / op2 operation.</returns>
        public static Fraction operator /(Fraction op1, Fraction op2)
        {
            int numerator = op1.numerator * op2.denominator;
            int denominator = op1.denominator * op2.numerator;

            return new Fraction(numerator, denominator);
        }
        #endregion

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

        /// <summary>
        /// Hashcode that reprsents this Fraction.
        /// </summary>
        /// <returns>Returns integer value of the hashcode.</returns>
        public override int GetHashCode()
        {
            return numerator.GetHashCode()^denominator.GetHashCode();
        }

        /// <summary>
        /// String representation of this Fraction
        /// </summary>
        /// <returns>Returns the string representation of this Fraction.</returns>
        public override string ToString()
        {
            StringBuilder s = new StringBuilder(numerator.ToString());
            if (denominator != 0 &&  denominator != 1)
            {
                s.Append("/");
                s.Append(denominator.ToString());
            }
            return s.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 projets, 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.

| Advertise | Privacy | Mobile
Web04 | 2.8.141022.2 | Last Updated 7 Jan 2008
Article Copyright 2008 by Marc Clifton
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid