// 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 de température
    /// </summary>
    public interface ITemperature
    {
        /// <summary>
        /// Obtient la valeur de cette température en kelvins
        /// </summary>
        double ValueInKelvins { get; }
    }

    /// <summary>
    /// Représente une température en kelvins
    /// </summary>
    public struct Kelvin : ITemperature, IComparable<Kelvin>, IEquatable<Kelvin>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Kelvin"/>.
        /// </summary>
        /// <param name="value">La valeur de cette température en kelvins</param>
        public Kelvin(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur de cette température.
        /// </summary>
        /// <value>
        /// La valeur de cette température en kelvins
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        /// <summary>
        /// Renvoie le zero absolu.
        /// </summary>
        public Kelvin AbsoluteZero
        {
            get { return new Kelvin(0); }
        }

        #region Operators

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

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

        /// <summary>
        /// Teste l'égalité de deux températures.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si les deux températures sont égales, false sinon.
        /// </returns>
        public static bool operator ==(Kelvin a, Kelvin b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux températures.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si les deux températures sont différentes, false sinon.
        /// </returns>
        public static bool operator !=(Kelvin a, Kelvin b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si la première température est inférieure à la deuxième.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si la première température est inférieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator <(Kelvin a, Kelvin b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si la première température est supérieure à la deuxième.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si la première température est supérieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator >(Kelvin a, Kelvin b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si la première température est inférieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si la première température est inférieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Kelvin a, Kelvin b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si la première température est supérieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si la première température est supérieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Kelvin a, Kelvin b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux températures.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// La somme des deux températures.
        /// </returns>
        public static Kelvin operator +(Kelvin a, Kelvin b)
        {
            return new Kelvin(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait la deuxième température de la première
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// La différence entre les deux températures.
        /// </returns>
        public static Kelvin operator -(Kelvin a, Kelvin b)
        {
            return new Kelvin(a.Value - b.Value);
        }

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

        /// <summary>
        /// Divise une température par un nombre.
        /// </summary>
        /// <param name="temperature">Température</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Kelvin operator /(Kelvin temperature, double divisor)
        {
            return new Kelvin(temperature.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(Kelvin 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} K", value);
        }

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

            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))
                {
                    temperature = new Kelvin(value);
                    return true;
                }
            }

            temperature = new Kelvin(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(Kelvin 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 Kelvin)
                return Equals((Kelvin) 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 ITemperature

        /// <summary>
        /// Obtient la valeur de cette température en kelvins
        /// </summary>
        double ITemperature.ValueInKelvins
        {
            get { return _value; }
        }

        #endregion
    }

    /// <summary>
    /// Représente une température en degrés Celsius
    /// </summary>
    public struct Celsius : ITemperature, IComparable<Celsius>, IEquatable<Celsius>, IFormattable
    {
        private readonly double _value;

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

        /// <summary>
        /// Obtient la valeur de cette température.
        /// </summary>
        /// <value>
        /// La valeur de cette température en degrés Celsius
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        /// <summary>
        /// Renvoie le zero absolu.
        /// </summary>
        public Celsius AbsoluteZero
        {
            get { return new Celsius(-273.15); }
        }

        #region Operators

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

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

        /// <summary>
        /// Teste l'égalité de deux températures.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si les deux températures sont égales, false sinon.
        /// </returns>
        public static bool operator ==(Celsius a, Celsius b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux températures.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si les deux températures sont différentes, false sinon.
        /// </returns>
        public static bool operator !=(Celsius a, Celsius b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si la première température est inférieure à la deuxième.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si la première température est inférieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator <(Celsius a, Celsius b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si la première température est supérieure à la deuxième.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si la première température est supérieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator >(Celsius a, Celsius b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si la première température est inférieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si la première température est inférieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Celsius a, Celsius b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si la première température est supérieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si la première température est supérieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Celsius a, Celsius b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux températures.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// La somme des deux températures.
        /// </returns>
        public static Celsius operator +(Celsius a, Celsius b)
        {
            return new Celsius(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait la deuxième température de la première
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// La différence entre les deux températures.
        /// </returns>
        public static Celsius operator -(Celsius a, Celsius b)
        {
            return new Celsius(a.Value - b.Value);
        }

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

        /// <summary>
        /// Divise une température par un nombre.
        /// </summary>
        /// <param name="temperature">Température</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Celsius operator /(Celsius temperature, double divisor)
        {
            return new Celsius(temperature.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(Celsius 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} °C", value);
        }

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

            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))
                {
                    temperature = new Celsius(value);
                    return true;
                }
            }

            temperature = new Celsius(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(Celsius 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 Celsius)
                return Equals((Celsius) 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 ITemperature

        /// <summary>
        /// Obtient la valeur de cette température en kelvins
        /// </summary>
        double ITemperature.ValueInKelvins
        {
            get { return _value + 273.15; }
        }

        #endregion
    }

    /// <summary>
    /// Représente une température en degrés Fahrenheit
    /// </summary>
    public struct Fahrenheit : ITemperature, IComparable<Fahrenheit>, IEquatable<Fahrenheit>, IFormattable
    {
        private readonly double _value;

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

        /// <summary>
        /// Obtient la valeur de cette température.
        /// </summary>
        /// <value>
        /// La valeur de cette température en degrés Fahrenheit
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        /// <summary>
        /// Renvoie le zero absolu.
        /// </summary>
        public Fahrenheit AbsoluteZero
        {
            get { return new Fahrenheit(-459.67); }
        }

        #region Operators

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

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

        /// <summary>
        /// Teste l'égalité de deux températures.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si les deux températures sont égales, false sinon.
        /// </returns>
        public static bool operator ==(Fahrenheit a, Fahrenheit b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux températures.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si les deux températures sont différentes, false sinon.
        /// </returns>
        public static bool operator !=(Fahrenheit a, Fahrenheit b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si la première température est inférieure à la deuxième.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si la première température est inférieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator <(Fahrenheit a, Fahrenheit b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si la première température est supérieure à la deuxième.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si la première température est supérieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator >(Fahrenheit a, Fahrenheit b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si la première température est inférieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si la première température est inférieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Fahrenheit a, Fahrenheit b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si la première température est supérieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// true si la première température est supérieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Fahrenheit a, Fahrenheit b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux températures.
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// La somme des deux températures.
        /// </returns>
        public static Fahrenheit operator +(Fahrenheit a, Fahrenheit b)
        {
            return new Fahrenheit(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait la deuxième température de la première
        /// </summary>
        /// <param name="a">Première température</param>
        /// <param name="b">Deuxième température</param>
        /// <returns>
        /// La différence entre les deux températures.
        /// </returns>
        public static Fahrenheit operator -(Fahrenheit a, Fahrenheit b)
        {
            return new Fahrenheit(a.Value - b.Value);
        }

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

        /// <summary>
        /// Divise une température par un nombre.
        /// </summary>
        /// <param name="temperature">Température</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Fahrenheit operator /(Fahrenheit temperature, double divisor)
        {
            return new Fahrenheit(temperature.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(Fahrenheit 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} °F", value);
        }

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

            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))
                {
                    temperature = new Fahrenheit(value);
                    return true;
                }
            }

            temperature = new Fahrenheit(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(Fahrenheit 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 Fahrenheit)
                return Equals((Fahrenheit) 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 ITemperature

        /// <summary>
        /// Obtient la valeur de cette température en kelvins
        /// </summary>
        double ITemperature.ValueInKelvins
        {
            get { return (_value + 459.67) / 1.8; }
        }

        #endregion
    }

    /// <summary>
    /// Fournit des méthodes d'extension pour les températures
    /// </summary>
    public static class TemperatureExtensions
    {
        /// <summary>
        /// Convertit une température en kelvins
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="temperature">Température à convertir</param>
        /// <returns>Valeur en kelvins</returns>
        public static Kelvin ToKelvin<T>(this T temperature)
            where T : ITemperature
        {
            return temperature.ValueInKelvins;
        }

        /// <summary>
        /// Convertit une température en degrés Celsius
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="temperature">Température à convertir</param>
        /// <returns>Valeur en degrés Celsius</returns>
        public static Celsius ToCelsius<T>(this T temperature)
            where T : ITemperature
        {
            return temperature.ValueInKelvins - 273.15;
        }

        /// <summary>
        /// Convertit une température en degrés Fahrenheit
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="temperature">Température à convertir</param>
        /// <returns>Valeur en degrés Fahrenheit</returns>
        public static Fahrenheit ToFahrenheit<T>(this T temperature)
            where T : ITemperature
        {
            return (temperature.ValueInKelvins * 1.8) - 459.67;
        }

    }
}