// Attention : ce fichier a été automatiquement généré par un
// template T4. Toute modification manuelle sera écrasée !!!

using System;
using System.Text.RegularExpressions;

namespace Developpez.Dotnet.Measures
{
    /// <summary>
    /// Représente une mesure d'angle
    /// </summary>
    public interface IAngle
    {
        /// <summary>
        /// Obtient la valeur de cet angle en radians
        /// </summary>
        double ValueInRadians { get; }
    }

    /// <summary>
    /// Représente un angle en radians
    /// </summary>
    public struct Radian : IAngle, IComparable<Radian>, IEquatable<Radian>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Radian"/>.
        /// </summary>
        /// <param name="value">La valeur de cet angle en radians</param>
        public Radian(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur ce cet angle.
        /// </summary>
        /// <value>
        /// La valeur de cet angle
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

        /// <summary>
        /// Effectue une conversion implicite de <see cref="double"/> vers <see cref="Developpez.Dotnet.Measures.Radian"/>.
        /// </summary>
        /// <param name="value">Valeur en radians.</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static implicit operator Radian(double value)
        {
            return new Radian(value);
        }

        /// <summary>
        /// Effectue une conversion explicite de <see cref="Developpez.Dotnet.Measures.Radian"/> vers <see cref="double"/>.
        /// </summary>
        /// <param name="angle">Angle</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static explicit operator double(Radian angle)
        {
            return angle.Value;
        }

        /// <summary>
        /// Teste l'égalité de deux angles.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si les deux angles sont égaux, false sinon.
        /// </returns>
        public static bool operator ==(Radian a, Radian b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux angles.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si les deux angles sont différents, false sinon.
        /// </returns>
        public static bool operator !=(Radian a, Radian b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si le premier angle est inférieur au deuxième.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si le premier angle est inférieur au deuxième, false sinon.
        /// </returns>
        public static bool operator <(Radian a, Radian b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si le premier angle est supérieur au deuxième.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si le premier angle est supérieur au deuxième, false sinon.
        /// </returns>
        public static bool operator >(Radian a, Radian b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si le premier angle est inférieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si le premier angle est inférieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Radian a, Radian b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si le premier angle est supérieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si le premier angle est supérieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Radian a, Radian b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux angles.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// La somme des deux angles.
        /// </returns>
        public static Radian operator +(Radian a, Radian b)
        {
            return new Radian(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait le deuxième angle du premier
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// La différence entre les deux angles.
        /// </returns>
        public static Radian operator -(Radian a, Radian b)
        {
            return new Radian(a.Value - b.Value);
        }

        /// <summary>
        /// Multiplie un angle par un nombre.
        /// </summary>
        /// <param name="angle">angle</param>
        /// <param name="multiplier">Multiplicateur</param>
        /// <returns>
        /// Le résultat de la multiplication.
        /// </returns>
        public static Radian operator *(Radian angle, double multiplier)
        {
            return new Radian(angle.Value*multiplier);
        }

        /// <summary>
        /// Divise un angle par un nombre.
        /// </summary>
        /// <param name="angle">Angle</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Radian operator /(Radian angle, double divisor)
        {
            return new Radian(angle.Value/divisor);
        }

        #endregion

        #region Methods

        /// <summary>
        /// Compare cette instance avec un objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(Radian other)
        {
            return Value.CompareTo(other.Value);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public override string ToString()
        {
            return ToString(null, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <param name="formatProvider">Le fournisseur à utiliser pour formater la valeur</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            var value = Value.ToString(format, formatProvider);
            return string.Format("{0} rad", value);
        }

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="angle">Angle.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out Radian angle)
        {
            var regex = new Regex(@"(?<value>.*) ?rad");

            if (regex.IsMatch(text) && regex.Match(text).Groups["value"].Success)
            {
                string valueText = regex.Match(text).Groups["value"].Value;

                double value;
                if (double.TryParse(valueText, out value))
                {
                    angle = new Radian(value);
                    return true;
                }
            }

            angle = new Radian(0);
            return false;
        }

        /// <summary>
        /// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>
        /// true si l'instance courante est égale au paramètre <paramref name="other"/> ; sinon, false.
        /// </returns>
        public bool Equals(Radian other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Determine si l'<see cref="System.Object"/> spécifié est égal à l'instance courante.
        /// </summary>
        /// <param name="obj">L' <see cref="System.Object"/> à comparer avec l'instance courante.</param>
        /// <returns>
        ///   <c>true</c> si l'<see cref="System.Object"/> spécifié est égal à cette instance ; sinon, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (obj is Radian)
                return Equals((Radian) obj);
            return false;
        }

        /// <summary>
        /// Retourne le hash code de cette instance
        /// </summary>
        /// <returns>
        /// Code de hashage de l'instance actuelle. 
        /// </returns>
        public override int GetHashCode()
        {
            unchecked
            {
                return Value.GetHashCode();
            }
        }

        #endregion

        #region Implementation of IAngle

        /// <summary>
        /// Obtient la valeur de cet angle en radians
        /// </summary>
        double IAngle.ValueInRadians
        {
            get { return _value; }
        }

        #endregion
    }

    /// <summary>
    /// Représente un angle en degrés
    /// </summary>
    public struct Degree : IAngle, IComparable<Degree>, IEquatable<Degree>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Degree"/>.
        /// </summary>
        /// <param name="value">La valeur de cet angle en degrés</param>
        public Degree(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur ce cet angle.
        /// </summary>
        /// <value>
        /// La valeur de cet angle
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

        /// <summary>
        /// Effectue une conversion implicite de <see cref="double"/> vers <see cref="Developpez.Dotnet.Measures.Degree"/>.
        /// </summary>
        /// <param name="value">Valeur en degrés.</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static implicit operator Degree(double value)
        {
            return new Degree(value);
        }

        /// <summary>
        /// Effectue une conversion explicite de <see cref="Developpez.Dotnet.Measures.Degree"/> vers <see cref="double"/>.
        /// </summary>
        /// <param name="angle">Angle</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static explicit operator double(Degree angle)
        {
            return angle.Value;
        }

        /// <summary>
        /// Teste l'égalité de deux angles.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si les deux angles sont égaux, false sinon.
        /// </returns>
        public static bool operator ==(Degree a, Degree b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux angles.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si les deux angles sont différents, false sinon.
        /// </returns>
        public static bool operator !=(Degree a, Degree b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si le premier angle est inférieur au deuxième.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si le premier angle est inférieur au deuxième, false sinon.
        /// </returns>
        public static bool operator <(Degree a, Degree b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si le premier angle est supérieur au deuxième.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si le premier angle est supérieur au deuxième, false sinon.
        /// </returns>
        public static bool operator >(Degree a, Degree b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si le premier angle est inférieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si le premier angle est inférieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Degree a, Degree b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si le premier angle est supérieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si le premier angle est supérieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Degree a, Degree b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux angles.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// La somme des deux angles.
        /// </returns>
        public static Degree operator +(Degree a, Degree b)
        {
            return new Degree(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait le deuxième angle du premier
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// La différence entre les deux angles.
        /// </returns>
        public static Degree operator -(Degree a, Degree b)
        {
            return new Degree(a.Value - b.Value);
        }

        /// <summary>
        /// Multiplie un angle par un nombre.
        /// </summary>
        /// <param name="angle">angle</param>
        /// <param name="multiplier">Multiplicateur</param>
        /// <returns>
        /// Le résultat de la multiplication.
        /// </returns>
        public static Degree operator *(Degree angle, double multiplier)
        {
            return new Degree(angle.Value*multiplier);
        }

        /// <summary>
        /// Divise un angle par un nombre.
        /// </summary>
        /// <param name="angle">Angle</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Degree operator /(Degree angle, double divisor)
        {
            return new Degree(angle.Value/divisor);
        }

        #endregion

        #region Methods

        /// <summary>
        /// Compare cette instance avec un objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(Degree other)
        {
            return Value.CompareTo(other.Value);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public override string ToString()
        {
            return ToString(null, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <param name="formatProvider">Le fournisseur à utiliser pour formater la valeur</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            var value = Value.ToString(format, formatProvider);
            return string.Format("{0}°", value);
        }

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="angle">Angle.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out Degree angle)
        {
            var regex = new Regex(@"(?<value>.*)°");

            if (regex.IsMatch(text) && regex.Match(text).Groups["value"].Success)
            {
                string valueText = regex.Match(text).Groups["value"].Value;

                double value;
                if (double.TryParse(valueText, out value))
                {
                    angle = new Degree(value);
                    return true;
                }
            }

            angle = new Degree(0);
            return false;
        }

        /// <summary>
        /// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>
        /// true si l'instance courante est égale au paramètre <paramref name="other"/> ; sinon, false.
        /// </returns>
        public bool Equals(Degree other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Determine si l'<see cref="System.Object"/> spécifié est égal à l'instance courante.
        /// </summary>
        /// <param name="obj">L' <see cref="System.Object"/> à comparer avec l'instance courante.</param>
        /// <returns>
        ///   <c>true</c> si l'<see cref="System.Object"/> spécifié est égal à cette instance ; sinon, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (obj is Degree)
                return Equals((Degree) obj);
            return false;
        }

        /// <summary>
        /// Retourne le hash code de cette instance
        /// </summary>
        /// <returns>
        /// Code de hashage de l'instance actuelle. 
        /// </returns>
        public override int GetHashCode()
        {
            unchecked
            {
                return Value.GetHashCode();
            }
        }

        #endregion

        #region Implementation of IAngle

        /// <summary>
        /// Obtient la valeur de cet angle en radians
        /// </summary>
        double IAngle.ValueInRadians
        {
            get { return _value / 180 * Math.PI; }
        }

        #endregion
    }

    /// <summary>
    /// Représente un angle en grades
    /// </summary>
    public struct Gradian : IAngle, IComparable<Gradian>, IEquatable<Gradian>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Gradian"/>.
        /// </summary>
        /// <param name="value">La valeur de cet angle en grades</param>
        public Gradian(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur ce cet angle.
        /// </summary>
        /// <value>
        /// La valeur de cet angle
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

        /// <summary>
        /// Effectue une conversion implicite de <see cref="double"/> vers <see cref="Developpez.Dotnet.Measures.Gradian"/>.
        /// </summary>
        /// <param name="value">Valeur en grades.</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static implicit operator Gradian(double value)
        {
            return new Gradian(value);
        }

        /// <summary>
        /// Effectue une conversion explicite de <see cref="Developpez.Dotnet.Measures.Gradian"/> vers <see cref="double"/>.
        /// </summary>
        /// <param name="angle">Angle</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static explicit operator double(Gradian angle)
        {
            return angle.Value;
        }

        /// <summary>
        /// Teste l'égalité de deux angles.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si les deux angles sont égaux, false sinon.
        /// </returns>
        public static bool operator ==(Gradian a, Gradian b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux angles.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si les deux angles sont différents, false sinon.
        /// </returns>
        public static bool operator !=(Gradian a, Gradian b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si le premier angle est inférieur au deuxième.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si le premier angle est inférieur au deuxième, false sinon.
        /// </returns>
        public static bool operator <(Gradian a, Gradian b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si le premier angle est supérieur au deuxième.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si le premier angle est supérieur au deuxième, false sinon.
        /// </returns>
        public static bool operator >(Gradian a, Gradian b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si le premier angle est inférieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si le premier angle est inférieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Gradian a, Gradian b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si le premier angle est supérieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// true si le premier angle est supérieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Gradian a, Gradian b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux angles.
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// La somme des deux angles.
        /// </returns>
        public static Gradian operator +(Gradian a, Gradian b)
        {
            return new Gradian(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait le deuxième angle du premier
        /// </summary>
        /// <param name="a">Premier angle</param>
        /// <param name="b">Deuxième angle</param>
        /// <returns>
        /// La différence entre les deux angles.
        /// </returns>
        public static Gradian operator -(Gradian a, Gradian b)
        {
            return new Gradian(a.Value - b.Value);
        }

        /// <summary>
        /// Multiplie un angle par un nombre.
        /// </summary>
        /// <param name="angle">angle</param>
        /// <param name="multiplier">Multiplicateur</param>
        /// <returns>
        /// Le résultat de la multiplication.
        /// </returns>
        public static Gradian operator *(Gradian angle, double multiplier)
        {
            return new Gradian(angle.Value*multiplier);
        }

        /// <summary>
        /// Divise un angle par un nombre.
        /// </summary>
        /// <param name="angle">Angle</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Gradian operator /(Gradian angle, double divisor)
        {
            return new Gradian(angle.Value/divisor);
        }

        #endregion

        #region Methods

        /// <summary>
        /// Compare cette instance avec un objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(Gradian other)
        {
            return Value.CompareTo(other.Value);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public override string ToString()
        {
            return ToString(null, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <param name="formatProvider">Le fournisseur à utiliser pour formater la valeur</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            var value = Value.ToString(format, formatProvider);
            return string.Format("{0} gon", value);
        }

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="angle">Angle.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out Gradian angle)
        {
            var regex = new Regex(@"(?<value>.*) ?gon");

            if (regex.IsMatch(text) && regex.Match(text).Groups["value"].Success)
            {
                string valueText = regex.Match(text).Groups["value"].Value;

                double value;
                if (double.TryParse(valueText, out value))
                {
                    angle = new Gradian(value);
                    return true;
                }
            }

            angle = new Gradian(0);
            return false;
        }

        /// <summary>
        /// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>
        /// true si l'instance courante est égale au paramètre <paramref name="other"/> ; sinon, false.
        /// </returns>
        public bool Equals(Gradian other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Determine si l'<see cref="System.Object"/> spécifié est égal à l'instance courante.
        /// </summary>
        /// <param name="obj">L' <see cref="System.Object"/> à comparer avec l'instance courante.</param>
        /// <returns>
        ///   <c>true</c> si l'<see cref="System.Object"/> spécifié est égal à cette instance ; sinon, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (obj is Gradian)
                return Equals((Gradian) obj);
            return false;
        }

        /// <summary>
        /// Retourne le hash code de cette instance
        /// </summary>
        /// <returns>
        /// Code de hashage de l'instance actuelle. 
        /// </returns>
        public override int GetHashCode()
        {
            unchecked
            {
                return Value.GetHashCode();
            }
        }

        #endregion

        #region Implementation of IAngle

        /// <summary>
        /// Obtient la valeur de cet angle en radians
        /// </summary>
        double IAngle.ValueInRadians
        {
            get { return _value / 200 * Math.PI; }
        }

        #endregion
    }

    /// <summary>
    /// Fournit des méthodes d'extension pour les angles
    /// </summary>
    public static class AngleExtensions
    {
        /// <summary>
        /// Convertit un angle en radians
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="angle">Angle à convertir</param>
        /// <returns>Valeur en radians</returns>
        public static Radian ToRadian<T>(this T angle)
            where T : IAngle
        {
            return angle.ValueInRadians;
        }

        /// <summary>
        /// Convertit un angle en degrés
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="angle">Angle à convertir</param>
        /// <returns>Valeur en degrés</returns>
        public static Degree ToDegree<T>(this T angle)
            where T : IAngle
        {
            return angle.ValueInRadians * 180 / Math.PI;
        }

        /// <summary>
        /// Convertit un angle en grades
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="angle">Angle à convertir</param>
        /// <returns>Valeur en grades</returns>
        public static Gradian ToGradian<T>(this T angle)
            where T : IAngle
        {
            return angle.ValueInRadians * 200 / Math.PI;
        }


        /// <summary>
        /// Renvoie le sinus de l'angle.
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'angle</typeparam>
        /// <param name="angle">Angle</param>
        /// <returns>Le sinus de l'angle</returns>
        public static double Sin<T>(this T angle)
            where T : IAngle
        {
            return Math.Sin(angle.ValueInRadians);
        }

        /// <summary>
        /// Renvoie le cosinus de l'angle.
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'angle</typeparam>
        /// <param name="angle">Angle</param>
        /// <returns>Le cosinus de l'angle</returns>
        public static double Cos<T>(this T angle)
            where T : IAngle
        {
            return Math.Cos(angle.ValueInRadians);
        }

        /// <summary>
        /// Renvoie la tangeante de l'angle.
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'angle</typeparam>
        /// <param name="angle">Angle</param>
        /// <returns>La tangeante de l'angle</returns>
        public static double Tan<T>(this T angle)
            where T : IAngle
        {
            return Math.Tan(angle.ValueInRadians);
        }

        /// <summary>
        /// Renvoie le sinus hyperbolique de l'angle.
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'angle</typeparam>
        /// <param name="angle">Angle</param>
        /// <returns>Le sinus hyperbolique de l'angle</returns>
        public static double Sinh<T>(this T angle)
            where T : IAngle
        {
            return Math.Sinh(angle.ValueInRadians);
        }

        /// <summary>
        /// Renvoie le cosinus hyperbolique de l'angle.
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'angle</typeparam>
        /// <param name="angle">Angle</param>
        /// <returns>Le cosinus hyperbolique de l'angle</returns>
        public static double Cosh<T>(this T angle)
            where T : IAngle
        {
            return Math.Cosh(angle.ValueInRadians);
        }

        /// <summary>
        /// Renvoie la tangeante hyperbolique de l'angle.
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'angle</typeparam>
        /// <param name="angle">Angle</param>
        /// <returns>La tangeante hyperbolique de l'angle</returns>
        public static double Tanh<T>(this T angle)
            where T : IAngle
        {
            return Math.Tanh(angle.ValueInRadians);
        }

    }
}